提出为组件和筛选，排序报错

projects/base-core/src/lib/components/tabulator-grid/tabulator-grid.component.ts

       
       // AJAX 配置
       ajaxInitialLoad: true,
-      ajaxContentType: 'json',
-      
-       // 设置为 false，强制 Tabulator 使用 ajaxRequestFunc
-      ajaxURL: '/api',
+       ajaxContentType: 'json',
+       
+        // 设置为 false，强制 Tabulator 使用 ajaxRequestFunc
+       ajaxURL: false,
       
       // 分页显示配置
       paginationCounter: 'rows',
     const componentId = this.containerId; // 用于调试标识
      defaultOptions.ajaxParams = function() {
        const callTime = new Date().toISOString();
-       console.group(`=== TabulatorGrid[${componentId}] AJAX 参数 ===`);
+       console.group(`🚨🚨🚨 TabulatorGrid[${componentId}] AJAX 参数函数被调用 🚨🚨🚨`);
+       console.log('⏰ 调用时间:', callTime);
+       console.log('🔍 调用堆栈:', new Error().stack);
        
        // 这里的 this 指向 Tabulator 实例
        const tabulatorInstance = this;
          hasGetPageSize: typeof tabulatorInstance.getPageSize === 'function',
          hasGetFilters: typeof tabulatorInstance.getFilters === 'function',
          hasGetSorters: typeof tabulatorInstance.getSorters === 'function',
-         tabulatorVersion: Tabulator.version
+         tabulatorVersion: Tabulator.version,
+         instanceMethods: Object.keys(tabulatorInstance).filter(key => typeof tabulatorInstance[key] === 'function').slice(0, 10)
+       });
+       
+       // 验证 Tabulator 配置
+       console.log('⚙️ Tabulator 配置检查:', {
+         sortMode: tabulatorInstance.options?.sortMode || 'unknown',
+         filterMode: tabulatorInstance.options?.filterMode || 'unknown',
+         paginationMode: tabulatorInstance.options?.paginationMode || 'unknown',
+         ajaxURL: tabulatorInstance.options?.ajaxURL,
+         hasAjaxRequestFunc: !!tabulatorInstance.options?.ajaxRequestFunc
        });
        
        // 提供安全的默认值，即使 Tabulator 方法未初始化
        const page = (tabulatorInstance.getPage && tabulatorInstance.getPage()) || 1;
        const pageSize = (tabulatorInstance.getPageSize && tabulatorInstance.getPageSize()) || componentPaginationSize || 20;
        
-       // 获取筛选器 - 传递 true 获取所有筛选器
-       const rawFilter = (tabulatorInstance.getFilters && tabulatorInstance.getFilters(true)) || [];
-       
-       // 获取排序器
-       const rawSort = (tabulatorInstance.getSorters && tabulatorInstance.getSorters()) || [];
-       
-       // 辅助函数：提取筛选器数据
-       function extractFilterData(filters: any[]): any[] {
-         if (!filters || !Array.isArray(filters)) return [];
-         return filters.map(f => {
-           // 提取基本属性，避免循环引用
-           const result: any = {};
-           if (f.field !== undefined) result.field = f.field;
-           if (f.type !== undefined) result.type = f.type;
-           if (f.value !== undefined) result.value = f.value;
-           return result;
-         });
-       }
-       
-       // 辅助函数：提取排序器数据
-       function extractSortData(sorters: any[]): any[] {
-         if (!sorters || !Array.isArray(sorters)) return [];
-         return sorters.map(s => {
-           // 提取基本属性，避免循环引用
-           const result: any = {};
-           if (s.field !== undefined) result.field = s.field;
-           if (s.dir !== undefined) result.dir = s.dir;
-           return result;
-         });
-       }
-       
-       // 提取纯数据
-       const filterData = extractFilterData(rawFilter);
-       const sortData = extractSortData(rawSort);
-       
-       console.log('⏰ 调用时间:', callTime);
-       console.log('📄 当前页码:', page);
-       console.log('📏 每页条数:', pageSize);
-       console.log('🔍 筛选条件:', filterData);
-       console.log('🔢 排序条件:', sortData);
-       console.groupEnd();
-       
-       const params = {
-         page,
-         size: pageSize,
-         filter: filterData,
-         sort: sortData
-       };
+        // 获取筛选器 - 传递 true 获取所有筛选器
+        const rawFilter = (tabulatorInstance.getFilters && tabulatorInstance.getFilters(true)) || [];
+        
+        // 获取排序器
+        const rawSort = (tabulatorInstance.getSorters && tabulatorInstance.getSorters()) || [];
+        
+        // 调试原始数据
+        console.log('🔧 原始数据检查:', {
+          rawFilterType: typeof rawFilter,
+          rawFilterIsArray: Array.isArray(rawFilter),
+          rawFilterLength: Array.isArray(rawFilter) ? rawFilter.length : 'N/A',
+          rawSortType: typeof rawSort,
+          rawSortIsArray: Array.isArray(rawSort),
+          rawSortLength: Array.isArray(rawSort) ? rawSort.length : 'N/A',
+          getPageSizeResult: tabulatorInstance.getPageSize ? tabulatorInstance.getPageSize() : 'N/A',
+          componentPaginationSize,
+          finalPageSize: pageSize
+        });
+        
+        // 安全字符串化函数，避免循环引用
+        function safeStringify(obj: any, space?: number): string {
+          const seen = new WeakSet();
+          return JSON.stringify(obj, (key, value) => {
+            if (typeof value === 'object' && value !== null) {
+              if (seen.has(value)) {
+                return '[Circular]';
+              }
+              seen.add(value);
+            }
+            return value;
+          }, space);
+        }
+        
+        // 辅助函数：提取筛选器数据
+        function extractFilterData(filters: any[]): any[] {
+          if (!filters || !Array.isArray(filters)) return [];
+          return filters.map(f => {
+            // 提取基本属性，避免循环引用
+            const result: any = {};
+            if (f.field !== undefined) result.field = f.field;
+            if (f.type !== undefined) result.type = f.type;
+            if (f.value !== undefined) {
+              // 安全处理值，避免循环引用
+              if (typeof f.value === 'object' && f.value !== null) {
+                try {
+                  // 尝试序列化并解析，去除循环引用
+                  const seen = new WeakSet();
+                  const safeValue = JSON.parse(JSON.stringify(f.value, (key, val) => {
+                    if (typeof val === 'object' && val !== null) {
+                      if (seen.has(val)) {
+                        return '[Circular]';
+                      }
+                      seen.add(val);
+                    }
+                    return val;
+                  }));
+                  result.value = safeValue;
+                } catch (e) {
+                  console.warn('筛选值包含循环引用，使用简化值:', e);
+                  result.value = '[Complex Object]';
+                }
+              } else {
+                result.value = f.value;
+              }
+            }
+            return result;
+          });
+        }
+        
+        // 辅助函数：提取排序器数据
+        function extractSortData(sorters: any[]): any[] {
+          if (!sorters || !Array.isArray(sorters)) return [];
+          return sorters.map(s => {
+            // 提取基本属性，避免循环引用
+            const result: any = {};
+            if (s.field !== undefined) {
+              // 安全处理字段值
+              if (typeof s.field === 'object' && s.field !== null) {
+                try {
+                  const seen = new WeakSet();
+                  const safeField = JSON.parse(JSON.stringify(s.field, (key, val) => {
+                    if (typeof val === 'object' && val !== null) {
+                      if (seen.has(val)) {
+                        return '[Circular]';
+                      }
+                      seen.add(val);
+                    }
+                    return val;
+                  }));
+                  result.field = safeField;
+                } catch (e) {
+                  console.warn('排序字段包含循环引用，使用简化值:', e);
+                  result.field = '[Complex Object]';
+                }
+              } else {
+                result.field = s.field;
+              }
+            }
+            if (s.dir !== undefined) result.dir = s.dir;
+            return result;
+          });
+        }
        
-       console.log(`🚀 TabulatorGrid[${componentId}] 返回参数:`, params);
-       return params;
+        // 提取纯数据
+        const filterData = extractFilterData(rawFilter);
+        const sortData = extractSortData(rawSort);
+        
+        console.log('⏰ 调用时间:', callTime);
+        console.log('📄 当前页码:', page);
+        console.log('📏 每页条数:', pageSize);
+        console.log('🔍 原始筛选器 (安全显示):', safeStringify(rawFilter));
+        console.log('🔍 处理后筛选条件:', filterData);
+        console.log('🔢 原始排序器 (安全显示):', safeStringify(rawSort));
+        console.log('🔢 处理后排序条件:', sortData);
+        
+        // 验证参数完整性
+        console.log('✅ 参数完整性检查:', {
+          hasFilters: filterData.length > 0,
+          hasSorters: sortData.length > 0,
+          filterFields: filterData.map(f => f.field),
+          sortFields: sortData.map(s => s.field),
+          pageValid: page > 0,
+          pageSizeValid: pageSize > 0
+        });
+        
+        console.groupEnd();
+        
+        const params = {
+          page,
+          size: pageSize,
+          filter: filterData,
+          sort: sortData
+        };
+        
+        console.log(`🚀 TabulatorGrid[${componentId}] 返回参数:`, safeStringify(params, 2));
+        return params;
      };
 
     // AJAX 响应处理
       const dataLoadedEvent = this.dataLoaded;
       const componentId = this.containerId;
       
-      const ajaxFunc = (url: string, config: any, params: any): Promise<any> => {
-        console.group(`🔍 TabulatorGrid[${componentId}] ajaxRequestFunc 被调用`);
-        console.log('📡 请求信息:', { 
-          url, 
-          configType: typeof config,
-          hasDataLoader: !!dataLoader 
-        });
-         console.log('📦 请求参数:', params);
-        
-        // 调试：记录调用堆栈以确认函数被 Tabulator 调用
-        console.trace('TabulatorGrid ajaxRequestFunc 调用堆栈');
-        console.groupEnd();
+       const ajaxFunc = (url: string, config: any, params: any): Promise<any> => {
+         console.group(`🔍 TabulatorGrid[${componentId}] ajaxRequestFunc 被调用`);
+         console.log('📡 请求信息:', { 
+           url, 
+           configType: typeof config,
+           configKeys: config ? Object.keys(config) : [],
+           hasDataLoader: !!dataLoader,
+           ajaxURL: config?.ajaxURL,
+           ajaxParamsFunc: typeof config?.ajaxParams === 'function'
+         });
+         
+         // 详细分析参数结构
+         console.log('📦 请求参数详情:', {
+           paramsType: typeof params,
+           isObject: params && typeof params === 'object',
+           keys: params ? Object.keys(params) : [],
+           page: params?.page,
+           size: params?.size,
+           hasFilter: 'filter' in params,
+           hasSort: 'sort' in params,
+           filterType: typeof params?.filter,
+           filterIsArray: Array.isArray(params?.filter),
+           filterLength: Array.isArray(params?.filter) ? params.filter.length : 0,
+           sortType: typeof params?.sort,
+           sortIsArray: Array.isArray(params?.sort),
+           sortLength: Array.isArray(params?.sort) ? params.sort.length : 0
+         });
+         
+          // 安全输出参数，避免循环引用
+          const safeStringify = (obj: any, space?: number): string => {
+            const seen = new WeakSet();
+            return JSON.stringify(obj, (key, value) => {
+              if (typeof value === 'object' && value !== null) {
+                if (seen.has(value)) {
+                  return '[Circular]';
+                }
+                seen.add(value);
+              }
+              return value;
+            }, space);
+          };
+          
+          console.log('📦 原始参数值 (安全显示):', safeStringify(params, 2));
+         
+         // 调试：记录调用堆栈以确认函数被 Tabulator 调用
+         console.trace('TabulatorGrid ajaxRequestFunc 调用堆栈');
+         console.groupEnd();
         
         return new Promise((resolve, reject) => {
           if (!dataLoader) {