提出为组件和筛选，排序ok

angular.json

         }
       }
     }
+  },
+  "cli": {
+    "analytics": false
   }
 }

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

       ajaxInitialLoad: true,
        ajaxContentType: 'json',
        
-        // 设置为 false，强制 Tabulator 使用 ajaxRequestFunc
-       ajaxURL: false,
+        // 设置为 api，强制 Tabulator 使用 ajaxRequestFunc
+       ajaxURL: '/api',
       
       // 分页显示配置
       paginationCounter: 'rows',
           finalPageSize: pageSize
         });
         
+        // 安全提取字段名函数，处理列组件和其他对象类型
+        function safeGetField(fieldObj: any): string {
+          if (typeof fieldObj === 'string') return fieldObj;
+          if (fieldObj?.getField && typeof fieldObj.getField === 'function') return fieldObj.getField();
+          if (fieldObj?.field) return String(fieldObj.field);
+          if (typeof fieldObj === 'object' && fieldObj !== null) {
+            try {
+              const str = String(fieldObj);
+              if (str !== '[object Object]') return str;
+            } catch (e) {}
+          }
+          return String(fieldObj);
+        }
+        
         // 安全字符串化函数，避免循环引用
         function safeStringify(obj: any, space?: number): string {
           const seen = new WeakSet();
                 return '[Circular]';
               }
               seen.add(value);
+              // 特殊处理Tabulator列组件，避免调用toJSON
+              if (value.getField && typeof value.getField === 'function') {
+                return `[TabulatorColumn:${value.getField()}]`;
+              }
+              // 特殊处理其他常见Tabulator对象
+              if (value.constructor && value.constructor.name) {
+                const name = value.constructor.name;
+                if (name.includes('Column') || name.includes('Component')) {
+                  return `[TabulatorObject:${name}]`;
+                }
+              }
             }
             return value;
           }, space);
           return filters.map(f => {
             // 提取基本属性，避免循环引用
             const result: any = {};
-            if (f.field !== undefined) result.field = f.field;
+            if (f.field !== undefined) result.field = safeGetField(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;
+                  // 使用safeStringify安全处理对象值
+                  const safeValueStr = safeStringify(f.value);
+                  if (safeValueStr.includes('[Circular]') || safeValueStr.includes('[TabulatorObject]')) {
+                    result.value = '[Complex Object]';
+                  } else {
+                    result.value = JSON.parse(safeValueStr);
+                  }
                 } catch (e) {
-                  console.warn('筛选值包含循环引用，使用简化值:', e);
+                  console.warn('筛选值处理失败，使用简化值:', e);
                   result.value = '[Complex Object]';
                 }
               } else {
             // 提取基本属性，避免循环引用
             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;
-              }
+              result.field = safeGetField(s.field);
             }
             if (s.dir !== undefined) result.dir = s.dir;
             return result;
         
         console.groupEnd();
         
+        // 最终验证：确保所有参数都是可序列化的基本类型
+        function ensureSerializable(obj: any): any {
+          if (obj === null || obj === undefined) return obj;
+          if (typeof obj === 'string' || typeof obj === 'number' || typeof obj === 'boolean') return obj;
+          if (Array.isArray(obj)) {
+            return obj.map(item => ensureSerializable(item));
+          }
+          if (typeof obj === 'object') {
+            const result: any = {};
+            for (const key in obj) {
+              if (obj.hasOwnProperty(key)) {
+                result[key] = ensureSerializable(obj[key]);
+              }
+            }
+            return result;
+          }
+          // 其他类型转换为字符串
+          return String(obj);
+        }
+        
         const params = {
           page,
           size: pageSize,
-          filter: filterData,
-          sort: sortData
+          filter: ensureSerializable(filterData),
+          sort: ensureSerializable(sortData)
         };
         
         console.log(`🚀 TabulatorGrid[${componentId}] 返回参数:`, safeStringify(params, 2));
+        
+        // 最终验证：确保参数可以安全序列化
+        try {
+          JSON.stringify(params);
+        } catch (e) {
+          console.error('❌ 参数序列化失败，使用安全备选值:', e);
+          return {
+            page,
+            size: pageSize,
+            filter: [],
+            sort: []
+          };
+        }
+        
         return params;
      };
 
 
     // 合并用户自定义选项（优先级最高）
     console.log('🔍 合并前配置:', {
-      defaultAjaxURL: defaultOptions.ajaxURL,
-      userOptions: this.options,
-      userAjaxURL: this.options?.['ajaxURL']
+      defaultAjaxURL: typeof defaultOptions.ajaxURL,
+      userOptionsKeys: Object.keys(this.options || {}),
+      userAjaxURLType: typeof this.options?.['ajaxURL']
     });
     const finalOptions = { ...defaultOptions, ...this.options };
 
       this.cellClick.emit(cell.getData());
     });
 
-    // 调试事件：监听排序和筛选变化
+    // 调试事件：监听排序和筛选变化 - 使用安全日志记录避免序列化问题
+    const safeStringifyForLog = (obj: any): 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);
+          if (value.getField && typeof value.getField === 'function') {
+            return `[TabulatorColumn:${value.getField()}]`;
+          }
+          if (value.constructor && value.constructor.name) {
+            const name = value.constructor.name;
+            if (name.includes('Column') || name.includes('Component')) {
+              return `[TabulatorObject:${name}]`;
+            }
+          }
+        }
+        return value;
+      }, 2);
+    };
+
     this.tabulator.on('dataSorting', (sorters: any) => {
-      console.log(`🔄 TabulatorGrid[${this.containerId}] 排序变化:`, JSON.stringify(sorters, null, 2));
+      console.log(`🔄 TabulatorGrid[${this.containerId}] 排序变化:`, safeStringifyForLog(sorters));
     });
 
     this.tabulator.on('dataFiltering', (filters: any) => {
-      console.log(`🔍 TabulatorGrid[${this.containerId}] 筛选变化:`, JSON.stringify(filters, null, 2));
+      console.log(`🔍 TabulatorGrid[${this.containerId}] 筛选变化:`, safeStringifyForLog(filters));
     });
 
     this.tabulator.on('dataFiltered', (filters: any, rows: any) => {
            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);
-          };
+           // 安全输出参数，避免循环引用
+           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);
+                 // 特殊处理Tabulator列组件，避免调用toJSON
+                 if (value.getField && typeof value.getField === 'function') {
+                   return `[TabulatorColumn:${value.getField()}]`;
+                 }
+                 // 特殊处理其他常见Tabulator对象
+                 if (value.constructor && value.constructor.name) {
+                   const name = value.constructor.name;
+                   if (name.includes('Column') || name.includes('Component')) {
+                     return `[TabulatorObject:${name}]`;
+                   }
+                 }
+               }
+               return value;
+             }, space);
+           };
           
           console.log('📦 原始参数值 (安全显示):', safeStringify(params, 2));