@nokecy/qc-ui 1.0.69 → 1.0.71

package/dist/cjs/ag-grid-plus/context/gridContext.d.ts

@@ -1,5 +1,7 @@
 import React from "react";
-export declare const GridPlusContext: React.Context<{
+import type { UseColumnSchemesReturn } from "../schemes/types";
+import type { UseQuerySchemesReturn } from "../querySchemes/types";
+export interface GridPlusContextValue {
     /**
      * 扩展列，允许运行时动态添加，用于展示用户自定义的列
      */
@@ -15,17 +17,40 @@ export declare const GridPlusContext: React.Context<{
      */
     onSaveColumnState: (gridKey: string, columnState: any[]) => void;
     /**
-     * 将当前列配置应用为“全局默认”，影响所有表格
+     * 将当前列配置应用为"全局默认"，影响所有表格
      * @param columnState 要应用的列配置
      */
     applyToGlobal: (gridKey: string) => void;
     /**
-     * 恢复当前用户当前表格为“默认列配置”
+     * 恢复当前用户当前表格为"默认列配置"
      * @param gridKey 表格唯一标识
      */
     resetCurrent: (gridKey: string) => void;
     /**
-     * 恢复所有用户当前表格为“默认列配置”
+     * 恢复所有用户当前表格为"默认列配置"
      */
     resetAll: (gridKey: string) => void;
-}>;
+    /**
+     * 列配置方案管理器（可选，新功能）
+     * 提供方案的增删改查、切换、保存等功能
+     */
+    schemeManager?: UseColumnSchemesReturn;
+    /**
+     * 查询方案管理器（可选，新功能）
+     * 提供查询表单项顺序的方案管理功能
+     */
+    querySchemeManager?: UseQuerySchemesReturn;
+    /**
+     * 当前查询表单项顺序
+     */
+    currentQueryOrder?: string[];
+    /**
+     * 更新查询表单项顺序
+     */
+    updateQueryOrder?: (order: string[]) => void;
+    /**
+     * 查询表单项列表（用于查询方案管理器）
+     */
+    queryFormItems?: any[];
+}
+export declare const GridPlusContext: React.Context<GridPlusContextValue>;

package/dist/cjs/ag-grid-plus/context/gridContext.js

@@ -12,5 +12,10 @@ var GridPlusContext = exports.GridPlusContext = /*#__PURE__*/_react.default.crea
   onSaveColumnState: function onSaveColumnState() {},
   applyToGlobal: function applyToGlobal() {},
   resetCurrent: function resetCurrent() {},
-  resetAll: function resetAll() {}
+  resetAll: function resetAll() {},
+  schemeManager: undefined,
+  querySchemeManager: undefined,
+  currentQueryOrder: undefined,
+  updateQueryOrder: function updateQueryOrder() {},
+  queryFormItems: []
 });

package/dist/cjs/ag-grid-plus/errors/ErrorBoundary.d.ts

@@ -0,0 +1,36 @@
+/**
+ * AG-Grid Plus 错误边界组件
+ * 用于捕获 React 渲染错误并提供友好的错误提示
+ */
+import React, { Component, ReactNode } from 'react';
+import { GridPlusError } from './types';
+interface ErrorBoundaryProps {
+    /** 子组件 */
+    children: ReactNode;
+    /** 自定义错误渲染函数 */
+    fallback?: (error: GridPlusError, errorInfo: React.ErrorInfo, retry: () => void) => ReactNode;
+    /** 错误回调 */
+    onError?: (error: GridPlusError, errorInfo: React.ErrorInfo) => void;
+    /** 是否显示错误详情(开发环境默认显示) */
+    showErrorDetails?: boolean;
+}
+interface ErrorBoundaryState {
+    hasError: boolean;
+    error: GridPlusError | null;
+    errorInfo: React.ErrorInfo | null;
+}
+/**
+ * Grid Plus 错误边界组件
+ * 捕获子组件树中的 JavaScript 错误,记录错误并展示降级 UI
+ */
+export declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): Partial<ErrorBoundaryState>;
+    componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
+    /**
+     * 重置错误状态,重新渲染组件
+     */
+    handleRetry: () => void;
+    render(): string | number | boolean | React.JSX.Element | Iterable<React.ReactNode> | null | undefined;
+}
+export {};

package/dist/cjs/ag-grid-plus/errors/ErrorBoundary.js

@@ -0,0 +1,143 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ErrorBoundary = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _antd = require("antd");
+var _types = require("./types");
+var _logger = require("../utils/logger");
+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 _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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+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); } /**
+ * AG-Grid Plus 错误边界组件
+ * 用于捕获 React 渲染错误并提供友好的错误提示
+ */
+/**
+ * Grid Plus 错误边界组件
+ * 捕获子组件树中的 JavaScript 错误,记录错误并展示降级 UI
+ */
+var ErrorBoundary = exports.ErrorBoundary = /*#__PURE__*/function (_Component) {
+  _inherits(ErrorBoundary, _Component);
+  var _super = _createSuper(ErrorBoundary);
+  function ErrorBoundary(props) {
+    var _this;
+    _classCallCheck(this, ErrorBoundary);
+    _this = _super.call(this, props);
+    /**
+     * 重置错误状态,重新渲染组件
+     */
+    _defineProperty(_assertThisInitialized(_this), "handleRetry", function () {
+      _this.setState({
+        hasError: false,
+        error: null,
+        errorInfo: null
+      });
+    });
+    _this.state = {
+      hasError: false,
+      error: null,
+      errorInfo: null
+    };
+    return _this;
+  }
+  _createClass(ErrorBoundary, [{
+    key: "componentDidCatch",
+    value: function componentDidCatch(error, errorInfo) {
+      // 将错误包装为 GridPlusError
+      var gridError = error instanceof _types.GridPlusError ? error : new _types.GridPlusError(error.message || '组件渲染错误', _types.ErrorType.RENDER_ERROR, _types.ErrorSeverity.HIGH, {
+        componentStack: errorInfo.componentStack
+      }, error);
+
+      // 记录错误
+      _logger.logger.error('组件渲染错误', gridError.getDetails());
+
+      // 更新状态
+      this.setState({
+        error: gridError,
+        errorInfo: errorInfo
+      });
+
+      // 调用用户提供的错误处理函数
+      if (this.props.onError) {
+        this.props.onError(gridError, errorInfo);
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$state = this.state,
+        hasError = _this$state.hasError,
+        error = _this$state.error,
+        errorInfo = _this$state.errorInfo;
+      var _this$props = this.props,
+        children = _this$props.children,
+        fallback = _this$props.fallback,
+        _this$props$showError = _this$props.showErrorDetails,
+        showErrorDetails = _this$props$showError === void 0 ? process.env.NODE_ENV === 'development' : _this$props$showError;
+      if (hasError && error) {
+        // 如果提供了自定义降级 UI
+        if (fallback && errorInfo) {
+          return fallback(error, errorInfo, this.handleRetry);
+        }
+
+        // 默认错误 UI
+        return /*#__PURE__*/_react.default.createElement(_antd.Result, {
+          status: "error",
+          title: "\u7EC4\u4EF6\u52A0\u8F7D\u5931\u8D25",
+          subTitle: error.getUserMessage(),
+          extra: [/*#__PURE__*/_react.default.createElement(_antd.Button, {
+            type: "primary",
+            key: "retry",
+            onClick: this.handleRetry
+          }, "\u91CD\u8BD5"), /*#__PURE__*/_react.default.createElement(_antd.Button, {
+            key: "refresh",
+            onClick: function onClick() {
+              return window.location.reload();
+            }
+          }, "\u5237\u65B0\u9875\u9762")]
+        }, showErrorDetails && /*#__PURE__*/_react.default.createElement("div", {
+          style: {
+            textAlign: 'left',
+            padding: '16px',
+            backgroundColor: '#f5f5f5',
+            borderRadius: '4px',
+            maxWidth: '800px',
+            margin: '0 auto'
+          }
+        }, /*#__PURE__*/_react.default.createElement("h4", null, "\u9519\u8BEF\u8BE6\u60C5:"), /*#__PURE__*/_react.default.createElement("pre", {
+          style: {
+            whiteSpace: 'pre-wrap',
+            wordBreak: 'break-word',
+            fontSize: '12px',
+            color: '#666'
+          }
+        }, error.message, '\n\n', error.stack, (errorInfo === null || errorInfo === void 0 ? void 0 : errorInfo.componentStack) && /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, '\n\n组件堆栈:', errorInfo.componentStack))));
+      }
+      return children;
+    }
+  }], [{
+    key: "getDerivedStateFromError",
+    value: function getDerivedStateFromError(error) {
+      // 更新 state 使下一次渲染能够显示降级 UI
+      return {
+        hasError: true
+      };
+    }
+  }]);
+  return ErrorBoundary;
+}(_react.Component);

package/dist/cjs/ag-grid-plus/errors/index.d.ts

@@ -0,0 +1,3 @@
+export { ErrorType, ErrorSeverity, GridPlusError } from './types';
+export type { ErrorHandlingConfig } from './types';
+export { ErrorBoundary } from './ErrorBoundary';

package/dist/cjs/ag-grid-plus/errors/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ErrorBoundary", {
+  enumerable: true,
+  get: function get() {
+    return _ErrorBoundary.ErrorBoundary;
+  }
+});
+Object.defineProperty(exports, "ErrorSeverity", {
+  enumerable: true,
+  get: function get() {
+    return _types.ErrorSeverity;
+  }
+});
+Object.defineProperty(exports, "ErrorType", {
+  enumerable: true,
+  get: function get() {
+    return _types.ErrorType;
+  }
+});
+Object.defineProperty(exports, "GridPlusError", {
+  enumerable: true,
+  get: function get() {
+    return _types.GridPlusError;
+  }
+});
+var _types = require("./types");
+var _ErrorBoundary = require("./ErrorBoundary");

package/dist/cjs/ag-grid-plus/errors/types.d.ts

@@ -0,0 +1,71 @@
+/**
+ * AG-Grid Plus 错误处理类型定义
+ */
+/// <reference types="react" />
+/**
+ * 错误类型枚举
+ */
+export declare enum ErrorType {
+    /** 网络错误 - 请求超时、网络中断 */
+    NETWORK_ERROR = "NETWORK_ERROR",
+    /** 服务器错误 - 5xx 错误 */
+    SERVER_ERROR = "SERVER_ERROR",
+    /** 业务错误 - 4xx 错误、业务逻辑错误 */
+    BUSINESS_ERROR = "BUSINESS_ERROR",
+    /** 数据格式错误 - 响应数据不符合预期 */
+    DATA_FORMAT_ERROR = "DATA_FORMAT_ERROR",
+    /** 渲染错误 - React 组件错误 */
+    RENDER_ERROR = "RENDER_ERROR",
+    /** 验证错误 - 输入验证失败 */
+    VALIDATION_ERROR = "VALIDATION_ERROR"
+}
+/**
+ * 错误严重级别
+ */
+export declare enum ErrorSeverity {
+    /** 低 - 不影响功能使用 */
+    LOW = "low",
+    /** 中 - 部分功能受影响 */
+    MEDIUM = "medium",
+    /** 高 - 核心功能受影响 */
+    HIGH = "high",
+    /** 严重 - 组件无法使用 */
+    CRITICAL = "critical"
+}
+/**
+ * Grid Plus 错误类
+ */
+export declare class GridPlusError extends Error {
+    /** 错误类型 */
+    type: ErrorType;
+    /** 严重级别 */
+    severity: ErrorSeverity;
+    /** 错误上下文信息 */
+    context?: any;
+    /** 原始错误对象 */
+    originalError?: Error;
+    /** 错误发生时间 */
+    timestamp: Date;
+    constructor(message: string, type: ErrorType, severity?: ErrorSeverity, context?: any, originalError?: Error);
+    /**
+     * 获取用户友好的错误消息
+     */
+    getUserMessage(): string;
+    /**
+     * 获取错误详情(用于日志)
+     */
+    getDetails(): Record<string, any>;
+}
+/**
+ * 错误处理配置
+ */
+export interface ErrorHandlingConfig {
+    /** 是否显示错误提示 */
+    showErrorMessage?: boolean;
+    /** 是否记录错误日志 */
+    logErrors?: boolean;
+    /** 自定义错误处理函数 */
+    onError?: (error: GridPlusError) => void;
+    /** 自定义错误渲染 */
+    renderError?: (error: GridPlusError, retry?: () => void) => React.ReactNode;
+}

package/dist/cjs/ag-grid-plus/errors/types.js

@@ -0,0 +1,137 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GridPlusError = exports.ErrorType = exports.ErrorSeverity = void 0;
+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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
+function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct.bind(); } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _isNativeFunction(fn) { try { return Function.toString.call(fn).indexOf("[native code]") !== -1; } catch (e) { return typeof fn === "function"; } }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+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); }
+/**
+ * AG-Grid Plus 错误处理类型定义
+ */
+/**
+ * 错误类型枚举
+ */
+var ErrorType = exports.ErrorType = /*#__PURE__*/function (ErrorType) {
+  ErrorType["NETWORK_ERROR"] = "NETWORK_ERROR";
+  ErrorType["SERVER_ERROR"] = "SERVER_ERROR";
+  ErrorType["BUSINESS_ERROR"] = "BUSINESS_ERROR";
+  ErrorType["DATA_FORMAT_ERROR"] = "DATA_FORMAT_ERROR";
+  ErrorType["RENDER_ERROR"] = "RENDER_ERROR";
+  ErrorType["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+  return ErrorType;
+}({});
+/**
+ * 错误严重级别
+ */
+var ErrorSeverity = exports.ErrorSeverity = /*#__PURE__*/function (ErrorSeverity) {
+  ErrorSeverity["LOW"] = "low";
+  ErrorSeverity["MEDIUM"] = "medium";
+  ErrorSeverity["HIGH"] = "high";
+  ErrorSeverity["CRITICAL"] = "critical";
+  return ErrorSeverity;
+}({});
+/**
+ * Grid Plus 错误类
+ */
+var GridPlusError = exports.GridPlusError = /*#__PURE__*/function (_Error) {
+  _inherits(GridPlusError, _Error);
+  var _super = _createSuper(GridPlusError);
+  function GridPlusError(message, type) {
+    var _this;
+    var severity = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ErrorSeverity.MEDIUM;
+    var context = arguments.length > 3 ? arguments[3] : undefined;
+    var originalError = arguments.length > 4 ? arguments[4] : undefined;
+    _classCallCheck(this, GridPlusError);
+    _this = _super.call(this, message);
+    /** 错误类型 */
+    _defineProperty(_assertThisInitialized(_this), "type", void 0);
+    /** 严重级别 */
+    _defineProperty(_assertThisInitialized(_this), "severity", void 0);
+    /** 错误上下文信息 */
+    _defineProperty(_assertThisInitialized(_this), "context", void 0);
+    /** 原始错误对象 */
+    _defineProperty(_assertThisInitialized(_this), "originalError", void 0);
+    /** 错误发生时间 */
+    _defineProperty(_assertThisInitialized(_this), "timestamp", void 0);
+    _this.name = 'GridPlusError';
+    _this.type = type;
+    _this.severity = severity;
+    _this.context = context;
+    _this.originalError = originalError;
+    _this.timestamp = new Date();
+
+    // 维护正确的原型链
+    Object.setPrototypeOf(_assertThisInitialized(_this), GridPlusError.prototype);
+    return _this;
+  }
+
+  /**
+   * 获取用户友好的错误消息
+   */
+  _createClass(GridPlusError, [{
+    key: "getUserMessage",
+    value: function getUserMessage() {
+      // 在生产环境下,返回更友好的消息
+      if (process.env.NODE_ENV === 'production') {
+        switch (this.type) {
+          case ErrorType.NETWORK_ERROR:
+            return '网络连接失败,请检查网络设置后重试';
+          case ErrorType.SERVER_ERROR:
+            return '服务器暂时无法响应,请稍后重试';
+          case ErrorType.BUSINESS_ERROR:
+            return this.message || '操作失败,请重试';
+          case ErrorType.DATA_FORMAT_ERROR:
+            return '数据格式错误,请联系技术支持';
+          case ErrorType.RENDER_ERROR:
+            return '组件加载失败,请刷新页面重试';
+          case ErrorType.VALIDATION_ERROR:
+            return this.message || '输入数据不符合要求';
+          default:
+            return '操作失败,请重试';
+        }
+      }
+      return this.message;
+    }
+
+    /**
+     * 获取错误详情(用于日志)
+     */
+  }, {
+    key: "getDetails",
+    value: function getDetails() {
+      return {
+        type: this.type,
+        severity: this.severity,
+        message: this.message,
+        timestamp: this.timestamp.toISOString(),
+        context: this.context,
+        stack: this.stack,
+        originalError: this.originalError ? {
+          name: this.originalError.name,
+          message: this.originalError.message,
+          stack: this.originalError.stack
+        } : undefined
+      };
+    }
+  }]);
+  return GridPlusError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+/**
+ * 错误处理配置
+ */

package/dist/cjs/ag-grid-plus/hooks/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * AG-Grid Plus Hooks
+ */
+export * from './useAgGridData';
+export * from './useAgGridCalculation';
+export * from './useGridState';
+export { useGridPlusColumnState } from './useGridPlusColumnState';

package/dist/cjs/ag-grid-plus/hooks/index.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  useGridPlusColumnState: true
+};
+Object.defineProperty(exports, "useGridPlusColumnState", {
+  enumerable: true,
+  get: function get() {
+    return _useGridPlusColumnState.useGridPlusColumnState;
+  }
+});
+var _useAgGridData = require("./useAgGridData");
+Object.keys(_useAgGridData).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useAgGridData[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _useAgGridData[key];
+    }
+  });
+});
+var _useAgGridCalculation = require("./useAgGridCalculation");
+Object.keys(_useAgGridCalculation).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useAgGridCalculation[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _useAgGridCalculation[key];
+    }
+  });
+});
+var _useGridState = require("./useGridState");
+Object.keys(_useGridState).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useGridState[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _useGridState[key];
+    }
+  });
+});
+var _useGridPlusColumnState = require("./useGridPlusColumnState");

package/dist/cjs/ag-grid-plus/hooks/useAgGridCalculation.d.ts

@@ -0,0 +1,88 @@
+import { GridApi } from 'ag-grid-community';
+/**
+ * 计算类型
+ */
+export type CalculationType = 'sum' | 'avg' | 'standardDeviation' | false;
+/**
+ * 计算列配置
+ */
+export interface CalculationColumn {
+    field: string;
+    calculateType: CalculationType;
+    /** 小数位数，默认 2 */
+    transactionAmount?: number;
+    /** 是否使用千分位格式化 */
+    formatWithCommas?: boolean;
+    /** 自定义渲染器（如果存在则跳过计算） */
+    cellRenderer?: any;
+}
+/**
+ * Hook 配置接口
+ */
+export interface UseAgGridCalculationConfig {
+    /** Grid API 引用 */
+    gridApi?: GridApi;
+    /** 所有列定义 */
+    allColDefs?: any[];
+    /** 行数据 */
+    rowData: any[];
+}
+/**
+ * Hook 返回值接口
+ */
+export interface UseAgGridCalculationReturn {
+    /** 计算并更新底部固定行 */
+    calculateSum: () => void;
+    /** 处理筛选变化 */
+    onFilterChanged: () => void;
+}
+/**
+ * 验证数值有效性
+ */
+declare function isValidNumber(value: any): boolean;
+/**
+ * 格式化数字（添加千分位）
+ */
+declare function formatNumber(value: number, decimalPlaces?: number): string;
+/**
+ * 求和函数
+ */
+declare function sumFn(field: string, displayedData: any[]): number;
+/**
+ * 平均值函数
+ */
+declare function avgFn(field: string, displayedData: any[]): number;
+/**
+ * 标准差函数
+ */
+declare function standardDeviationFn(field: string, displayedData: any[]): number;
+/**
+ * AG-Grid 计算列管理 Hook
+ *
+ * @description
+ * 处理 AG-Grid 底部固定行的聚合计算（求和、平均值、标准差）
+ *
+ * @example
+ * ```tsx
+ * const { calculateSum, onFilterChanged } = useAgGridCalculation({
+ *   gridApi,
+ *   allColDefs,
+ *   rowData
+ * });
+ *
+ * // 在筛选变化时调用
+ * <AgGridReact onFilterChanged={onFilterChanged} />
+ * ```
+ */
+export declare function useAgGridCalculation(config: UseAgGridCalculationConfig): UseAgGridCalculationReturn;
+/**
+ * 导出工具函数供外部使用
+ */
+export declare const calculationUtils: {
+    isValidNumber: typeof isValidNumber;
+    formatNumber: typeof formatNumber;
+    sumFn: typeof sumFn;
+    avgFn: typeof avgFn;
+    standardDeviationFn: typeof standardDeviationFn;
+};
+export {};