@yibozhang/pro-table 16.0.6 → 16.0.7

package/esm2022/lib/pro-table.component.mjs

@@ -180,17 +180,19 @@ export class ProTableComponent {
             };
         });
         if (res.code === 0) {
-            if (!isEqual(res.data.tabColumn, initColumns)) {
-                const initRes = await this.persistRemoteColumns(initColumns);
-                if (initRes) {
+            const serverColumns = Array.isArray(res?.data?.tabColumn)
+                ? res.data.tabColumn
+                : [];
+            // 以远程数据为主：保留远程顺序与显示状态，仅做字段结构合并（新增字段追加、删除字段过滤）
+            const merged = this.mergeServerColumnsWithInit(serverColumns, initColumns);
+            if (!isEqual(serverColumns, merged)) {
+                const persistRes = await this.persistRemoteColumns(merged);
+                if (persistRes) {
                     this.queryDynamicColumns();
                 }
                 return false;
             }
-            else {
-                console.log("一致");
-                return true;
-            }
+            return true;
         }
         else if (res.code === 10) {
             // code === 10 表示未初始化，需要继续执行后续逻辑
@@ -200,6 +202,38 @@ export class ProTableComponent {
             return false;
         }
     }
+    mergeServerColumnsWithInit(serverColumns, initColumns) {
+        const initByField = new Map();
+        initColumns.forEach((c) => initByField.set(c.field, c));
+        const merged = [];
+        const seen = new Set();
+        // 1) 保留远程顺序与显示状态；同步 header/sortName；过滤掉前端已不存在的 field
+        serverColumns.forEach((sc) => {
+            const field = sc?.field;
+            if (!field || !initByField.has(field) || seen.has(field))
+                return;
+            const init = initByField.get(field);
+            merged.push({
+                ...sc,
+                header: init.header,
+                sortName: init.sortName ?? null,
+            });
+            seen.add(field);
+        });
+        // 2) 新增字段（远程不存在）追加到末尾，默认显示用 initColumns 的 isShow
+        initColumns.forEach((ic) => {
+            if (seen.has(ic.field))
+                return;
+            merged.push({
+                field: ic.field,
+                isShow: ic.isShow,
+                header: ic.header,
+                sortName: ic.sortName ?? null,
+            });
+            seen.add(ic.field);
+        });
+        return merged;
+    }
     async queryDynamicColumns() {
         if (!this.tableName || !this.columnRemote)
             return;
@@ -1143,4 +1177,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                 type: HostListener,
                 args: ["window:resize"]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pro-table.component.js","sourceRoot":"","sources":["../../../../pro-table/src/lib/pro-table.component.ts","../../../../pro-table/src/lib/pro-table.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  AfterContentInit,\r\n  Component,\r\n  ContentChild,\r\n  ContentChildren,\r\n  EventEmitter,\r\n  HostListener,\r\n  Inject,\r\n  Input,\r\n  OnInit,\r\n  Optional,\r\n  Output,\r\n  QueryList,\r\n  TemplateRef,\r\n} from \"@angular/core\";\r\nimport { cloneDeep, hasIn, isNil, debounce, isEqual } from \"lodash-es\";\r\nimport { PRO_TABLE_DEFAULT_COLUMN, PRO_TABLE_DEFAULT_PROPS } from \"./constants\";\r\nimport {\r\n  AutoCompleteFieldProps,\r\n  CheckboxFieldProps,\r\n  OptionsType,\r\n  ProTableColumn,\r\n  ProTablePageInfo,\r\n  ProTableRequestResult,\r\n  ProTableValuesChange,\r\n  SelectFieldProps,\r\n} from \"./type\";\r\nimport { PRO_TABLE_COLUMN_REMOTE, ProTableRemoteColumnService } from \"./tokens\";\r\nimport { isObservable, lastValueFrom } from 'rxjs';\r\n\r\n@Component({\r\n  selector: \"app-pro-table\",\r\n  templateUrl: \"./pro-table.component.html\",\r\n  styleUrls: [\"./pro-table.component.less\"],\r\n})\r\nexport class ProTableComponent implements OnInit, AfterContentInit {\r\n  @Input() showSearchBtn: boolean = true;\r\n\r\n  @Input() showClearBtn: boolean = true;\r\n\r\n  @Input() title: string | null = null;\r\n\r\n  @Input() tableName: string = \"\";\r\n\r\n  @Input() multiRow: boolean = false;\r\n\r\n  @Input() columns: ProTableColumn[] = [];\r\n\r\n  @Input() showSearchBar: boolean = true;\r\n\r\n  @Input() showActionBar: boolean = true;\r\n\r\n  @Input() confirmBtnText: string = \"查询\";\r\n\r\n  @Input() clearBtnText: string = \"清空\";\r\n\r\n  @Input() labelWidth: string = \"90px\";\r\n\r\n  @Input() labelAlign: string = \"right\";\r\n\r\n  @Input() formItemWidth: string = \"330px\";\r\n\r\n  @Input() dataSource: any[] = [];\r\n\r\n  @Input() bordered: boolean = true;\r\n\r\n  @Input() outerBordered: boolean = true;\r\n\r\n  @Input() showPagination: boolean = true;\r\n\r\n  @Input() frontPagination: boolean = false;\r\n\r\n  @Input() scroll: { x?: string | number; y?: string | number } | null = null;\r\n\r\n  @Input() request: (params: any) => Promise<ProTableRequestResult>;\r\n\r\n  @Input() summaryData: Record<string, any> | null = null;\r\n\r\n  // 排序模式：local 本地排序；server 在线排序（提交给接口）\r\n  @Input() sortMode: \"local\" | \"server\" = \"local\";\r\n\r\n  @Input() showColumnSetting: boolean = false;\r\n\r\n  // 是否开启多列排序（默认单列）\r\n  @Input() multipleSort: boolean = false;\r\n\r\n  @Input() showCheckbox: boolean = false;\r\n\r\n  // 判断行是否禁用的函数\r\n  @Input() rowDisabled: (data: any) => boolean = () => false;\r\n\r\n  @Input() rerenderOnResize: boolean = true;\r\n\r\n  // 是否自动触发请求\r\n  @Input() autoTriggerRequest: boolean = true;\r\n\r\n  @Input() customTableRender?: TemplateRef<any>;\r\n\r\n  @Output() onRowClick = new EventEmitter<any>();\r\n\r\n  @Output() onRowDbClick = new EventEmitter<any>();\r\n\r\n  @Output() onValuesChange = new EventEmitter<ProTableValuesChange>();\r\n\r\n  @Output() onResetFormBeforeReload = new EventEmitter<any>();\r\n\r\n  @ContentChild(\"actionBar\") actionBarTpl!: TemplateRef<any>;\r\n\r\n  @ContentChild(\"ImgActionBar\") imgActionBarTpl!: TemplateRef<any>;\r\n\r\n  @ContentChildren(TemplateRef) allTemplates!: QueryList<TemplateRef<any>>;\r\n\r\n  private _savedSearchParams: any = {};\r\n\r\n  // 存储所有自定义模板的引用\r\n  private customTemplates = new Map<string, TemplateRef<any>>();\r\n\r\n  // 记录各列排序状态：'ascend' | 'descend' | null\r\n\r\n  private _sortMap: Record<string, \"ascend\" | \"descend\" | null> = {};\r\n\r\n  // 记录多列排序的优先级（后设置的优先）\r\n  private _sortPriority: string[] = [];\r\n\r\n  // 存储每个 autoComplete 字段的防抖函数\r\n  private _autoCompleteDebounceMap: Map<string, (event: Event) => void> =\r\n    new Map();\r\n\r\n  // 仅在初始化时运行列配置预检查，避免后续调用重复触发\r\n  private _preCheckDone: boolean = false;\r\n\r\n  _columns: ProTableColumn[] = [];\r\n\r\n  // 筛选表单数据存储\r\n  _searchParams: any = {};\r\n\r\n  // 筛选表单list渲染数据\r\n  _searchFiledColumns: ProTableColumn[] = [];\r\n\r\n  _pageInfo: ProTablePageInfo = {\r\n    pageIndex: 1,\r\n    pageSize: 15,\r\n    total: 100,\r\n    pageSizeOptions: [10, 15, 20, 50, 100, 500, 1000],\r\n  };\r\n\r\n  _loading: boolean = false;\r\n\r\n  _selectedTableRow: any = null;\r\n\r\n  // 选中的行数据（用于复选框选择）- 保留用于兼容性\r\n  _selectedRows: any[] = [];\r\n\r\n  // 全选状态\r\n  _checkedAll: boolean = false;\r\n\r\n  // 半选状态（部分选中）\r\n  _indeterminate: boolean = false;\r\n\r\n  // 远程columns\r\n  _serverColumns: ProTableColumn[] = [];\r\n\r\n  // 存储 autoComplete 字段的数据源\r\n  _autoCompleteDataSources: Record<string, any[]> = {};\r\n\r\n  // 控制表格显示状态，用于重新挂载\r\n  _showTable: boolean = true;\r\n\r\n  // 防抖定时器，用于窗口大小调整\r\n  private resizeDebounce: any;\r\n\r\n  @HostListener(\"window:resize\")\r\n  onWindowResize() {\r\n    if (!this.rerenderOnResize) return;\r\n\r\n    if (this.resizeDebounce) {\r\n      clearTimeout(this.resizeDebounce);\r\n    }\r\n\r\n    this.resizeDebounce = setTimeout(() => {\r\n      // 通过 ngIf 重新挂载表格\r\n      this._showTable = false;\r\n      setTimeout(() => {\r\n        this._showTable = true;\r\n      }, 0);\r\n    }, 150);\r\n  }\r\n  constructor(\r\n    @Optional()\r\n    @Inject(PRO_TABLE_COLUMN_REMOTE)\r\n    private columnRemote: ProTableRemoteColumnService | null\r\n  ) {}\r\n\r\n  private async fetchRemoteColumns() {\r\n    if (!this.columnRemote?.getCol || !this.tableName) {\r\n      return null;\r\n    }\r\n    try {\r\n      const res = await this.columnRemote.getCol(this.tableName, this.multiRow);\r\n      return res;\r\n    } catch (error) {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  private async persistRemoteColumns(columns: any[]) {\r\n    if (!this.columnRemote?.setCol || !this.tableName) {\r\n      return null;\r\n    }\r\n    try {\r\n      const result = this.columnRemote.setCol(\r\n        this.tableName,\r\n        columns,\r\n        this.multiRow\r\n      );\r\n      if (result && isObservable(result)) {\r\n        return await lastValueFrom(result);\r\n      }\r\n      return result;\r\n    } catch (error) {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  async ngOnInit(): Promise<void> {\r\n    this._searchParams = {};\r\n    this.formateInnerColumns(this.columns);\r\n    await this.setSearchParams(this.columns);\r\n\r\n    // 使用 Proxy 包装 _searchParams，拦截表单项值变化并向外发出事件\r\n    this._searchParams = this.createSearchParamsProxy(this._searchParams);\r\n    if (this.autoTriggerRequest) {\r\n      this.handleQuery();\r\n    }\r\n    this.queryDynamicColumns();\r\n  }\r\n\r\n  ngAfterContentInit() {\r\n    // 自动注册所有自定义模板\r\n    // 注意：此时所有 ContentChild 和 ContentChildren 都已初始化完成\r\n    this.autoRegisterTemplates();\r\n  }\r\n\r\n  private async preCheckServerColumns(): Promise<boolean> {\r\n    const res = await this.fetchRemoteColumns();\r\n    if (!res) return false;\r\n    const initColumns = this.columns\r\n      .filter((col) => !col.auxiliaryColumn)\r\n      .map((column) => {\r\n        return {\r\n          field: column.prop,\r\n          isShow: !column.hideInTable, // 默认全部显示\r\n          header: column.title,\r\n          sortName: column.sortName || null,\r\n        };\r\n      });\r\n    if (res.code === 0) {\r\n      if (!isEqual(res.data.tabColumn, initColumns)) {\r\n        const initRes = await this.persistRemoteColumns(initColumns);\r\n        if (initRes) {\r\n          this.queryDynamicColumns();\r\n        }\r\n\r\n        return false;\r\n      } else {\r\n        console.log(\"一致\");\r\n        return true;\r\n      }\r\n    } else if (res.code === 10) {\r\n      // code === 10 表示未初始化，需要继续执行后续逻辑\r\n      return true;\r\n    } else {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  private async queryDynamicColumns() {\r\n    if (!this.tableName || !this.columnRemote) return;\r\n    if (!this._preCheckDone) {\r\n      const checkResult = await this.preCheckServerColumns();\r\n      this._preCheckDone = true;\r\n      if (!checkResult) return;\r\n    }\r\n    const res = await this.fetchRemoteColumns();\r\n    if (!res) return;\r\n    if (res.code === 0) {\r\n      const _tabColumn = res.data.tabColumn.map((item) => {\r\n        return {\r\n          title: item.header,\r\n          prop: item.field,\r\n          sortName: item.sortName,\r\n          hideInTable: !item.isShow,\r\n        };\r\n      });\r\n      this._serverColumns = _tabColumn;\r\n      this.updateTableColumns(_tabColumn);\r\n    } else if (res.code === 10) {\r\n      // 如果未设置接口返回，需要默认调用一次修改函数初始化数据\r\n      const initColumns = this.columns\r\n        .filter((col) => !col.auxiliaryColumn)\r\n        .map((column) => {\r\n          return {\r\n            field: column.prop,\r\n            isShow: true, // 默认全部显示\r\n            header: column.title,\r\n            sortName: column.sortName || null,\r\n          };\r\n        });\r\n\r\n      // 调用修改接口初始化数据\r\n      const initRes = await this.persistRemoteColumns(initColumns);\r\n      if (initRes) {\r\n        this.queryDynamicColumns();\r\n      }\r\n    }\r\n  }\r\n\r\n  private formateInnerColumns(columns: ProTableColumn[]) {\r\n    this._columns = columns\r\n      .filter((item) => !item.hideInTable)\r\n      .map((item) => {\r\n        return { ...PRO_TABLE_DEFAULT_COLUMN, ...item } as ProTableColumn;\r\n      });\r\n  }\r\n\r\n  // 自动注册模板的方法\r\n  private autoRegisterTemplates() {\r\n    // 获取所有模板\r\n    const allTemplatesArray = this.allTemplates.toArray();\r\n\r\n    // 获取所有需要自定义模板的列\r\n    const columnsWithCustomRender = this._columns.filter(\r\n      (col) => col.customRender\r\n    );\r\n\r\n    // 获取所有需要自定义label模板的列（使用原始columns，确保顺序正确）\r\n    const columnsWithCustomLabel = this.columns.filter(\r\n      (col) => col.customLabelRender\r\n    );\r\n\r\n    // 计算需要的模板总数\r\n    const customRenderCount = columnsWithCustomRender.length;\r\n    const totalNeededTemplates = customRenderCount + columnsWithCustomLabel.length;\r\n\r\n    // 识别并排除特殊模板（actionBar 和 imgActionBar）\r\n    const specialTemplateIndices = new Set<number>();\r\n    \r\n    // 尝试找到 actionBarTpl 在 allTemplatesArray 中的位置\r\n    if (this.actionBarTpl) {\r\n      const actionBarIndex = this.findTemplateIndex(allTemplatesArray, this.actionBarTpl);\r\n      if (actionBarIndex !== -1) {\r\n        specialTemplateIndices.add(actionBarIndex);\r\n      }\r\n    }\r\n    \r\n    // 尝试找到 imgActionBarTpl 在 allTemplatesArray 中的位置\r\n    if (this.imgActionBarTpl) {\r\n      const imgActionBarIndex = this.findTemplateIndex(allTemplatesArray, this.imgActionBarTpl);\r\n      if (imgActionBarIndex !== -1) {\r\n        specialTemplateIndices.add(imgActionBarIndex);\r\n      }\r\n    }\r\n\r\n    // 如果无法通过引用找到特殊模板，使用备用策略\r\n    // 备用策略：假设最后的模板是特殊模板\r\n    const specialTemplateCount = (this.actionBarTpl ? 1 : 0) + (this.imgActionBarTpl ? 1 : 0);\r\n    if (specialTemplateIndices.size === 0 && specialTemplateCount > 0) {\r\n      for (let i = allTemplatesArray.length - specialTemplateCount; i < allTemplatesArray.length; i++) {\r\n        specialTemplateIndices.add(i);\r\n      }\r\n    }\r\n\r\n    // 提取列模板（排除特殊模板）\r\n    const columnTemplates: TemplateRef<any>[] = [];\r\n    allTemplatesArray.forEach((tpl, index) => {\r\n      if (!specialTemplateIndices.has(index)) {\r\n        columnTemplates.push(tpl);\r\n      }\r\n    });\r\n\r\n    // 验证模板数量\r\n    if (columnTemplates.length !== totalNeededTemplates) {\r\n      console.warn(\r\n        `ProTable: 模板数量不匹配！需要 ${totalNeededTemplates} 个列模板，实际有 ${columnTemplates.length} 个。请检查 customRender 和 customLabelRender 配置。`\r\n      );\r\n    }\r\n\r\n    // 注册自定义渲染模板\r\n    columnsWithCustomRender.forEach((column, index) => {\r\n      const templateName = column.customRender!;\r\n      if (index < columnTemplates.length) {\r\n        this.customTemplates.set(templateName, columnTemplates[index]);\r\n      } else {\r\n        console.error(`ProTable: 未找到模板 \"${templateName}\"，索引 ${index} 超出范围`);\r\n      }\r\n    });\r\n\r\n    // 注册自定义label模板（从 customRenderCount 之后开始）\r\n    columnsWithCustomLabel.forEach((column, index) => {\r\n      const templateName = column.customLabelRender!;\r\n      const templateIndex = customRenderCount + index;\r\n      if (templateIndex < columnTemplates.length) {\r\n        this.customTemplates.set(templateName, columnTemplates[templateIndex]);\r\n      } else {\r\n        console.error(`ProTable: 未找到label模板 \"${templateName}\"，索引 ${templateIndex} 超出范围`);\r\n      }\r\n    });\r\n  }\r\n\r\n  // 尝试在数组中找到模板的索引（使用多种比较方式）\r\n  private findTemplateIndex(templates: TemplateRef<any>[], target: TemplateRef<any>): number {\r\n    // 方法1：引用相等性\r\n    let index = templates.indexOf(target);\r\n    if (index !== -1) return index;\r\n\r\n    // 方法2：通过 elementRef 比较\r\n    try {\r\n      const targetElementRef = (target as any).elementRef;\r\n      if (targetElementRef) {\r\n        for (let i = 0; i < templates.length; i++) {\r\n          const tplElementRef = (templates[i] as any).elementRef;\r\n          if (tplElementRef === targetElementRef) {\r\n            return i;\r\n          }\r\n        }\r\n      }\r\n    } catch (e) {\r\n      // 忽略错误\r\n    }\r\n\r\n    // 方法3：通过 Angular 内部属性比较\r\n    try {\r\n      const targetContainer = (target as any)._declarationTContainer;\r\n      if (targetContainer) {\r\n        for (let i = 0; i < templates.length; i++) {\r\n          const tplContainer = (templates[i] as any)._declarationTContainer;\r\n          if (tplContainer === targetContainer) {\r\n            return i;\r\n          }\r\n        }\r\n      }\r\n    } catch (e) {\r\n      // 忽略错误\r\n    }\r\n\r\n    return -1;\r\n  }\r\n\r\n  // 设置筛选表单默认属性\r\n  private setSearchFormDefaultProp(columns: ProTableColumn[]) {\r\n    columns.forEach((item) => {\r\n      if (item.valueType) {\r\n        if (item.fieldProps) {\r\n          item.fieldProps = {\r\n            ...PRO_TABLE_DEFAULT_PROPS[item.valueType],\r\n            ...item.fieldProps,\r\n          };\r\n        } else {\r\n          item.fieldProps = { ...PRO_TABLE_DEFAULT_PROPS[item.valueType] };\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n  // 动态设置Options\r\n  private setSelectRequest(columns: ProTableColumn[]) {\r\n    columns.map(async (item) => {\r\n      if (item.fieldProps && hasIn(item.fieldProps, \"request\")) {\r\n        try {\r\n          const options = await (\r\n            item.fieldProps as SelectFieldProps\r\n          ).request?.();\r\n          (item.fieldProps as SelectFieldProps).options = options;\r\n        } catch (error) {\r\n          (item.fieldProps as SelectFieldProps).options = [];\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n  private async setSearchParams(columns: ProTableColumn[]) {\r\n    this._searchFiledColumns = [];\r\n    columns\r\n      .filter((item) => {\r\n        const flag = !item.hideInSearch && item.valueType;\r\n        if (flag) {\r\n          this._searchFiledColumns.push(cloneDeep(item));\r\n        }\r\n        return flag;\r\n      })\r\n      .forEach((column) => {\r\n        const key = column.fieldProps?.name || column.prop;\r\n        let defaultValue = PRO_TABLE_DEFAULT_PROPS[column.valueType].value;\r\n\r\n        // 对于checkbox类型，从options中找出checked为true的项作为默认值\r\n        if (column.valueType === \"checkbox\") {\r\n          const checkedValues = (column.fieldProps?.options || [])\r\n            .filter((opt: OptionsType) => opt.checked)\r\n            .map((opt: OptionsType) => opt.value);\r\n          this._searchParams[key] =\r\n            checkedValues.length > 0 ? checkedValues : defaultValue;\r\n        } else {\r\n          this._searchParams[key] = column.fieldProps?.value || defaultValue;\r\n        }\r\n\r\n        // 初始化 autoComplete 数据源\r\n        if (column.valueType === \"autoComplete\") {\r\n          this._autoCompleteDataSources[key] = [];\r\n        }\r\n      });\r\n\r\n    // 根据列的 order 字段进行排序，未设置 order 的放在最后\r\n    this._searchFiledColumns.sort((a: any, b: any) => {\r\n      const aOrder = isNil(a?.order) ? Number.MAX_SAFE_INTEGER : a.order;\r\n      const bOrder = isNil(b?.order) ? Number.MAX_SAFE_INTEGER : b.order;\r\n      if (aOrder === bOrder) return 0;\r\n      return aOrder - bOrder;\r\n    });\r\n\r\n    this.setSearchFormDefaultProp(this._searchFiledColumns);\r\n\r\n    // 并发加载所有需要异步获取的选项\r\n    this.setSelectRequest(this._searchFiledColumns);\r\n  }\r\n\r\n  private updateTableColumns(injectColumns: ProTableColumn[]) {\r\n    // 1. 使用最原始的columns作为数据源，确保辅助列完全不受影响\r\n    const originalColumns = cloneDeep(this.columns);\r\n\r\n    // 2. 处理字段映射（如果提供了fields参数）\r\n    let processedInjectColumns = injectColumns;\r\n\r\n    // 3. 分离辅助列和非辅助列（使用原始数据）\r\n    const nonAuxiliaryColumns = originalColumns.filter(\r\n      (col) => !col.auxiliaryColumn\r\n    );\r\n\r\n    // 4. 按照injectColumns的顺序重新排列非辅助列\r\n    const reorderedNonAuxiliaryColumns: ProTableColumn[] = [];\r\n    const remainingNonAuxiliaryColumns = [...nonAuxiliaryColumns]; // 复制一份用于查找和移除\r\n\r\n    processedInjectColumns.forEach((injectCol) => {\r\n      // 查找非辅助列中对应的下标\r\n      const existingColIndex = remainingNonAuxiliaryColumns.findIndex(\r\n        (col) => col.prop === injectCol.prop\r\n      );\r\n      if (existingColIndex !== -1) {\r\n        // 如果找到相同列，用injectColumns中的属性覆盖原始columns中的属性\r\n        const existingCol = remainingNonAuxiliaryColumns[existingColIndex];\r\n\r\n        const updatedCol = { ...existingCol, ...injectCol };\r\n        reorderedNonAuxiliaryColumns.push(updatedCol);\r\n        // 从剩余数组中移除，避免重复\r\n        remainingNonAuxiliaryColumns.splice(existingColIndex, 1);\r\n      } else {\r\n        // 如果没找到对应的列，直接添加injectColumns中的列\r\n        reorderedNonAuxiliaryColumns.push(injectCol);\r\n      }\r\n    });\r\n\r\n    // 5. 处理剩余的原始columns中的非辅助列（在injectColumns中未出现的列）\r\n    // 这些列应该被隐藏（设置hideInTable为true）\r\n    remainingNonAuxiliaryColumns.forEach((remainingCol) => {\r\n      const hiddenCol = { ...remainingCol, hideInTable: true };\r\n      reorderedNonAuxiliaryColumns.push(hiddenCol);\r\n    });\r\n\r\n    // 6. 按照原始columns的顺序重新组合：保持辅助列的原始位置和属性\r\n    const finalColumns: ProTableColumn[] = [];\r\n    let nonAuxiliaryIndex = 0;\r\n    let auxiliaryIndex = 0;\r\n\r\n    originalColumns.forEach((originalCol) => {\r\n      if (originalCol.auxiliaryColumn) {\r\n        // 如果是辅助列，使用原始列数据，完全不进行任何修改\r\n        finalColumns.push(originalCol);\r\n        auxiliaryIndex++;\r\n      } else {\r\n        // 如果是非辅助列，使用重新排序后的列，但保留原始列的所有属性\r\n        const reorderedCol = reorderedNonAuxiliaryColumns[nonAuxiliaryIndex];\r\n        if (reorderedCol) {\r\n          // 合并原始列和重新排序后的列，确保保留所有原始属性\r\n          const mergedCol = { ...originalCol, ...reorderedCol };\r\n          finalColumns.push(mergedCol);\r\n        } else {\r\n          // 如果重新排序后的列不存在，使用原始列\r\n          finalColumns.push(originalCol);\r\n        }\r\n        nonAuxiliaryIndex++;\r\n      }\r\n    });\r\n    this.formateInnerColumns(finalColumns);\r\n  }\r\n\r\n  // 通过 Proxy 监听 _searchParams 的属性变更\r\n  private createSearchParamsProxy(target: any) {\r\n    const self = this;\r\n    const handler: ProxyHandler<any> = {\r\n      set(obj: any, prop: string | symbol, value: any) {\r\n        const key = String(prop);\r\n        const oldVal = obj[key];\r\n        if (oldVal === value) {\r\n          obj[key] = value;\r\n          return true;\r\n        }\r\n        obj[key] = value;\r\n        try {\r\n          self.onValuesChange.emit({\r\n            key,\r\n            value,\r\n            params: self.getSearchParams(),\r\n          });\r\n        } catch (e) {}\r\n        return true;\r\n      },\r\n    };\r\n    return new Proxy(target, handler);\r\n  }\r\n\r\n  private clearEmptySearchParams() {\r\n    const cloneSearchParams = cloneDeep(this._searchParams);\r\n    return cloneSearchParams;\r\n  }\r\n\r\n  private buildServerSortPayload() {\r\n    // 构建激活排序集合（按优先级从低到高，末尾优先）\r\n    const activeKeys = this._sortPriority.filter((k) => !!this._sortMap[k]);\r\n    if (activeKeys.length === 0) return null;\r\n    const sorts = activeKeys.map((field) => {\r\n      // 查找对应的列配置，优先使用sortName字段\r\n      const column = this._columns.find((col) => col.prop === field);\r\n      const sortField = column?.sortName || field;\r\n      return {\r\n        field: sortField,\r\n        order: this._sortMap[field]!,\r\n      };\r\n    });\r\n    if (this.multipleSort) {\r\n      return sorts; // 以数组形式提交多列排序\r\n    }\r\n    const [first] = sorts;\r\n    return first; // 兼容单列结构 { field, order }\r\n  }\r\n\r\n  private sortDataSourceInPlace() {\r\n    if (!Array.isArray(this.dataSource) || this.dataSource.length === 0) return;\r\n    const activeKeys = this._sortPriority.filter((k) => !!this._sortMap[k]);\r\n    if (activeKeys.length === 0) return;\r\n\r\n    // 复制一份优先级，从前到后优先级从低到高（最后设置的字段优先）\r\n    const keysInPriority = [...activeKeys];\r\n    this.dataSource.sort((a: any, b: any) => {\r\n      for (let i = keysInPriority.length - 1; i >= 0; i--) {\r\n        const field = keysInPriority[i];\r\n        const order = this._sortMap[field]!;\r\n        const av = a?.[field];\r\n        const bv = b?.[field];\r\n        const cmp = this.compareValues(av, bv);\r\n        if (cmp !== 0) return order === \"ascend\" ? cmp : -cmp;\r\n      }\r\n      return 0;\r\n    });\r\n  }\r\n\r\n  private compareValues(aVal: any, bVal: any): number {\r\n    if (aVal == null && bVal == null) return 0;\r\n    if (aVal == null) return -1;\r\n    if (bVal == null) return 1;\r\n    if (aVal instanceof Date && bVal instanceof Date) {\r\n      return aVal.getTime() - bVal.getTime();\r\n    }\r\n    if (typeof aVal === \"boolean\" && typeof bVal === \"boolean\") {\r\n      return aVal === bVal ? 0 : aVal ? 1 : -1;\r\n    }\r\n    if (typeof aVal === \"number\" && typeof bVal === \"number\") {\r\n      return aVal - bVal;\r\n    }\r\n    if (typeof aVal === \"string\" && typeof bVal === \"string\") {\r\n      return aVal.localeCompare(bVal);\r\n    }\r\n    const aNum = Number(aVal);\r\n    const bNum = Number(bVal);\r\n    if (!isNaN(aNum) && !isNaN(bNum)) return aNum - bNum;\r\n    return String(aVal).localeCompare(String(bVal));\r\n  }\r\n\r\n  // 执行 autoComplete 数据源查询（实际执行逻辑）\r\n  private executeAutoCompleteDataSource(event: Event, column: ProTableColumn) {\r\n    const fieldKey = column.fieldProps?.name || column.prop;\r\n\r\n    if (\r\n      (column.fieldProps as AutoCompleteFieldProps).dataSource &&\r\n      typeof (column.fieldProps as AutoCompleteFieldProps).dataSource ===\r\n        \"function\"\r\n    ) {\r\n      try {\r\n        const result = (column.fieldProps as AutoCompleteFieldProps).dataSource(\r\n          event\r\n        );\r\n        // 如果返回的是 Promise，处理异步结果\r\n        if (result instanceof Promise) {\r\n          result\r\n            .then((data) => {\r\n              this._autoCompleteDataSources[fieldKey] = data || [];\r\n            })\r\n            .catch((error) => {\r\n              console.error(\"AutoComplete dataSource error:\", error);\r\n              this._autoCompleteDataSources[fieldKey] = [];\r\n            });\r\n        } else {\r\n          // 同步返回结果\r\n          this._autoCompleteDataSources[fieldKey] = result || [];\r\n        }\r\n      } catch (error) {\r\n        console.error(\"AutoComplete dataSource error:\", error);\r\n        this._autoCompleteDataSources[fieldKey] = [];\r\n      }\r\n    }\r\n  }\r\n\r\n  public getSearchParams(options?: {\r\n    useSaved?: boolean; // 使用最近一次查询提交的参数，默认为 false；false 为当前表单值\r\n  }): any {\r\n    const { useSaved = false } = options || {};\r\n    const rawParams = useSaved ? this._savedSearchParams : this._searchParams;\r\n    const params = cloneDeep(rawParams || {});\r\n\r\n    return {\r\n      params,\r\n      pageInfo: {\r\n        pageIndex: this._pageInfo.pageIndex,\r\n        pageSize: this._pageInfo.pageSize,\r\n      },\r\n      // 在线排序模式：把排序对象提交给接口\r\n      ...(this.sortMode === \"server\"\r\n        ? { sort: this.buildServerSortPayload() }\r\n        : {}),\r\n    };\r\n  }\r\n\r\n  public reload(afterDelete?: boolean) {\r\n    this.handleQuery(afterDelete);\r\n  }\r\n\r\n  public setFieldsValue(fields: Record<string, any>) {\r\n    Object.keys(fields).forEach((k) => {\r\n      this._searchParams[k] = fields[k]; // 保留 Proxy，逐项赋值触发拦截\r\n    });\r\n  }\r\n\r\n  public setFieldValue(key: string, value: any) {\r\n    this._searchParams[key] = value;\r\n  }\r\n\r\n  public clearSelectedRow() {\r\n    this._selectedTableRow = null;\r\n  }\r\n\r\n  public async setColumns(\r\n    columns: ProTableColumn[],\r\n    options?: {\r\n      reload?: boolean; // 是否重新加载数据，默认为 false\r\n    }\r\n  ): Promise<void> {\r\n    // 更新 columns 输入属性\r\n    this.columns = cloneDeep(columns);\r\n\r\n    // 重新格式化内部列\r\n    this.formateInnerColumns(this.columns);\r\n\r\n    // 重新设置搜索参数（异步操作）\r\n    // 先清空旧的搜索参数，避免旧数据残留\r\n    this._searchParams = {};\r\n    await this.setSearchParams(this.columns);\r\n\r\n    // 重新创建 Proxy，确保表单项值变化能正常触发事件\r\n    this._searchParams = this.createSearchParamsProxy(this._searchParams);\r\n\r\n    // 重新注册模板（如果组件已经初始化完成）\r\n    if (this.allTemplates) {\r\n      this.autoRegisterTemplates();\r\n    }\r\n\r\n    // 如果设置了 reload 选项为 true，则重新查询数据\r\n    if (options?.reload === true) {\r\n      this.handleQuery();\r\n    }\r\n  }\r\n\r\n  public getSelectedRowData<T = any>(): T {\r\n    return this._selectedTableRow;\r\n  }\r\n\r\n  public getCheckedRows<T = any>(): T[] {\r\n    if (!this.showCheckbox) {\r\n      return [];\r\n    }\r\n    // 返回当前数据源中所有 checked 为 true 的项\r\n    // 注意：如果需要获取所有页的选中项，需要遍历所有数据源或使用 _selectedRowIds\r\n    return this.dataSource.filter((row) => row.checked === true) as T[];\r\n  }\r\n\r\n  // 获取指定名称的模板\r\n  getTemplate(name: string | undefined): TemplateRef<any> | null {\r\n    if (!name) return null;\r\n    return this.customTemplates.get(name) || null;\r\n  }\r\n\r\n  getToolTipTextValue(column: ProTableColumn, data: any): string {\r\n    const key =\r\n      column.customRender && this.getTemplate(column.customRender)\r\n        ? \"\"\r\n        : column.ellipsis\r\n        ? column.prop\r\n        : \"\";\r\n    return !key ? \"\" : data[key];\r\n  }\r\n\r\n  getTableRowChecked(data: any) {\r\n    // 启用复选框时：行高亮应与复选框选中状态一致（支持多选）\r\n    if (this.showCheckbox) {\r\n      return this.isRowChecked(data);\r\n    }\r\n    // 未启用复选框时：仍然使用单选行高亮\r\n    if (!this._selectedTableRow) return false;\r\n    return JSON.stringify(this._selectedTableRow) === JSON.stringify(data);\r\n  }\r\n\r\n  // 检查行是否被禁用\r\n  isRowDisabled(data: any): boolean {\r\n    if (!this.showCheckbox) return false;\r\n    return this.rowDisabled ? this.rowDisabled(data) : false;\r\n  }\r\n\r\n  // 检查行是否被复选框选中（数据驱动模式）\r\n  isRowChecked(data: any): boolean {\r\n    if (!this.showCheckbox) return false;\r\n    // 直接读取数据对象的 checked 属性\r\n    return data.checked === true;\r\n  }\r\n\r\n  // 切换行的选中状态（数据驱动模式，保留用于兼容）\r\n  toggleRowChecked(data: any, checked: boolean, event?: Event) {\r\n    if (event) {\r\n      event.stopPropagation(); // 阻止事件冒泡，避免触发行点击\r\n    }\r\n    // 如果行被禁用，不允许切换选中状态\r\n    if (this.isRowDisabled(data)) {\r\n      return;\r\n    }\r\n\r\n    // 直接设置数据对象的 checked 属性\r\n    data.checked = checked;\r\n\r\n    // 同步更新 _selectedRows（用于兼容性）\r\n    const index = this._selectedRows.findIndex((row) =>\r\n      this.isSameRow(row, data)\r\n    );\r\n    if (checked) {\r\n      if (index === -1) {\r\n        this._selectedRows.push(data);\r\n      }\r\n      // 勾选复选框时同步设置高亮选中行\r\n      this._selectedTableRow = data;\r\n    } else {\r\n      if (index > -1) {\r\n        this._selectedRows.splice(index, 1);\r\n      }\r\n      // 若当前高亮行为该行，则取消高亮\r\n      if (\r\n        this._selectedTableRow &&\r\n        this.isSameRow(this._selectedTableRow, data)\r\n      ) {\r\n        this._selectedTableRow = null;\r\n      }\r\n    }\r\n\r\n    this.updateCheckAllStatus();\r\n  }\r\n\r\n  // 更新全选状态（数据驱动模式）\r\n  updateCheckAllStatus() {\r\n    if (!this.showCheckbox || !Array.isArray(this.dataSource)) {\r\n      this._checkedAll = false;\r\n      this._indeterminate = false;\r\n      return;\r\n    }\r\n    // 只计算可用的行（未禁用的行）\r\n    const availableRows = this.dataSource.filter(\r\n      (row) => !this.isRowDisabled(row)\r\n    );\r\n    // 基于数据对象的 checked 属性计算\r\n    const checkedCount = availableRows.filter(\r\n      (row) => row.checked === true\r\n    ).length;\r\n    const totalCount = availableRows.length;\r\n    this._checkedAll =\r\n      totalCount > 0 && checkedCount > 0 && checkedCount === totalCount;\r\n    this._indeterminate = checkedCount > 0 && checkedCount < totalCount;\r\n  }\r\n\r\n  // 全选/取消全选（数据驱动模式）\r\n  toggleCheckAll(checked: boolean, event?: Event) {\r\n    if (event) {\r\n      event.stopPropagation();\r\n    }\r\n\r\n    // 只处理可用的行（未禁用的行）\r\n    const availableRows = this.dataSource.filter(\r\n      (row) => !this.isRowDisabled(row)\r\n    );\r\n\r\n    // 批量设置 checked 属性\r\n    availableRows.forEach((row) => {\r\n      row.checked = checked;\r\n    });\r\n\r\n    // 同步更新 _selectedRows（用于兼容性）\r\n    if (checked) {\r\n      this._selectedRows = [...availableRows];\r\n      // 同步设置高亮选中行为第一条可选数据\r\n      this._selectedTableRow =\r\n        availableRows.length > 0 ? availableRows[0] : null;\r\n    } else {\r\n      this._selectedRows = [];\r\n      // 取消高亮\r\n      this._selectedTableRow = null;\r\n    }\r\n\r\n    this.updateCheckAllStatus();\r\n  }\r\n\r\n  // 获取选中的行数据（保留用于兼容性）\r\n  getSelectedRows(): any[] {\r\n    return this.getCheckedRows();\r\n  }\r\n\r\n  // 处理行 checkbox 变化事件（数据驱动模式）\r\n  handleRowCheckedChange(data: any, checked: boolean): void {\r\n    if (this.isRowDisabled(data)) {\r\n      return;\r\n    }\r\n\r\n    // 数据对象的 checked 属性已经通过双向绑定自动更新\r\n    // 这里只需要同步更新 _selectedRows\r\n\r\n    // 同步更新 _selectedRows（用于兼容性）\r\n    const index = this._selectedRows.findIndex((row) =>\r\n      this.isSameRow(row, data)\r\n    );\r\n    if (checked) {\r\n      if (index === -1) {\r\n        this._selectedRows.push(data);\r\n      }\r\n      // 勾选复选框时同步设置高亮选中行\r\n      this._selectedTableRow = data;\r\n    } else {\r\n      if (index > -1) {\r\n        this._selectedRows.splice(index, 1);\r\n      }\r\n      // 若当前高亮行为该行，则取消高亮\r\n      if (\r\n        this._selectedTableRow &&\r\n        this.isSameRow(this._selectedTableRow, data)\r\n      ) {\r\n        this._selectedTableRow = null;\r\n      }\r\n    }\r\n\r\n    // 更新全选状态\r\n    this.updateCheckAllStatus();\r\n  }\r\n\r\n  // 刷新全选状态（用于其他场景）\r\n  refreshCheckAllStatus(): void {\r\n    this.updateCheckAllStatus();\r\n  }\r\n\r\n  // 获取行的唯一标识（用于跨页选中）\r\n  private getRowId(data: any): string | number | undefined {\r\n    return data.id ?? data.key ?? undefined;\r\n  }\r\n\r\n  // 判断两行是否为同一行\r\n  private isSameRow(row1: any, row2: any): boolean {\r\n    const id1 = this.getRowId(row1);\r\n    const id2 = this.getRowId(row2);\r\n\r\n    if (id1 !== undefined && id2 !== undefined) {\r\n      return id1 === id2;\r\n    }\r\n\r\n    // fallback 到 JSON 比较\r\n    return JSON.stringify(row1) === JSON.stringify(row2);\r\n  }\r\n\r\n  // 清空选中的行（数据驱动模式）\r\n  clearSelectedRows() {\r\n    // 清空当前数据源中所有项的 checked 状态\r\n    if (Array.isArray(this.dataSource)) {\r\n      this.dataSource.forEach((row) => {\r\n        row.checked = false;\r\n      });\r\n    }\r\n\r\n    this._selectedRows = [];\r\n    this._checkedAll = false;\r\n    this._indeterminate = false;\r\n    this._selectedTableRow = null;\r\n  }\r\n\r\n  handleFieldCheckBoxChange(checkBoxOptions: OptionsType[], key: string) {\r\n    this.setFieldsValue({\r\n      [key]: checkBoxOptions\r\n        .filter((item) => item.checked)\r\n        .map((item) => item.value),\r\n    });\r\n  }\r\n\r\n  handleSearch() {\r\n    this._savedSearchParams = this.clearEmptySearchParams();\r\n    this._pageInfo.pageIndex = 1;\r\n    this.handleQuery();\r\n  }\r\n\r\n  handleResetForm() {\r\n    Object.keys(this._searchParams).forEach((key) => {\r\n      const targetColumn = this._searchFiledColumns.find((item) => {\r\n        return (item.fieldProps?.name || item.prop) === key;\r\n      });\r\n\r\n      // 对于checkbox类型，需要特殊处理默认值\r\n      if (targetColumn?.valueType === \"checkbox\") {\r\n        // 从原始columns配置中获取初始配置，以确保使用正确的默认值\r\n        const originalColumn = this.columns.find((item) => {\r\n          return (item.fieldProps?.name || item.prop) === key;\r\n        });\r\n\r\n        // 从原始options中找出checked为true的项作为默认值\r\n        const originalFieldProps = originalColumn?.fieldProps as\r\n          | CheckboxFieldProps\r\n          | undefined;\r\n        const checkedValues = (originalFieldProps?.options || [])\r\n          .filter((opt: OptionsType) => opt.checked)\r\n          .map((opt: OptionsType) => opt.value);\r\n        const defaultValue =\r\n          checkedValues.length > 0\r\n            ? checkedValues\r\n            : PRO_TABLE_DEFAULT_PROPS[targetColumn.valueType].value;\r\n\r\n        this._searchParams[key] = defaultValue;\r\n\r\n        // 根据默认值恢复options的checked状态，使用原始options的结构\r\n        const defaultValues = Array.isArray(defaultValue) ? defaultValue : [];\r\n        const originalOptions = originalFieldProps?.options || [];\r\n        const targetFieldProps = targetColumn.fieldProps as CheckboxFieldProps;\r\n        targetFieldProps.options = originalOptions.map((item: OptionsType) => {\r\n          return {\r\n            ...item,\r\n            checked: defaultValues.includes(item.value),\r\n          };\r\n        });\r\n      } else {\r\n        this._searchParams[key] = targetColumn?.fieldProps\r\n          ? targetColumn?.fieldProps.value ||\r\n            PRO_TABLE_DEFAULT_PROPS[targetColumn.valueType].value\r\n          : PRO_TABLE_DEFAULT_PROPS[targetColumn.valueType].value;\r\n      }\r\n    });\r\n\r\n    this._savedSearchParams = {};\r\n    this._pageInfo.pageIndex = 1;\r\n    this.onResetFormBeforeReload.emit();\r\n    this.handleQuery();\r\n  }\r\n\r\n  handlePageIndexChange(pageIndex: number) {\r\n    this._pageInfo.pageIndex = pageIndex;\r\n    this.handleQuery();\r\n  }\r\n\r\n  handlePageSizeChange(pageSize: any) {\r\n    this._pageInfo.pageSize = pageSize;\r\n    this._pageInfo.pageIndex = 1;\r\n    this.handleQuery();\r\n  }\r\n\r\n  async handleQuery(afterDelete?: boolean) {\r\n    // 删除后刷新且当前页仅剩一条记录时，若不在第一页则先回退一页\r\n    if (\r\n      afterDelete &&\r\n      Array.isArray(this.dataSource) &&\r\n      this.dataSource.length === 1 &&\r\n      this._pageInfo.pageIndex > 1\r\n    ) {\r\n      this._pageInfo.pageIndex = this._pageInfo.pageIndex - 1;\r\n    }\r\n\r\n    this._loading = true;\r\n    if (this.request) {\r\n      try {\r\n        const result = await this.request({\r\n          params: this.clearEmptySearchParams(),\r\n          pageInfo: {\r\n            pageIndex: this._pageInfo.pageIndex,\r\n            pageSize: this._pageInfo.pageSize,\r\n          },\r\n          // 在线排序模式：把排序对象提交给接口\r\n          ...(this.sortMode === \"server\"\r\n            ? { sort: this.buildServerSortPayload() }\r\n            : {}),\r\n        });\r\n\r\n        // 查询后默认不保留跨页选中状态：每次返回的数据均初始化为未选中\r\n        if (this.showCheckbox) {\r\n          this.dataSource = (result.data || []).map((item) => {\r\n            return {\r\n              ...item,\r\n              checked: false,\r\n            };\r\n          });\r\n        } else {\r\n          this.dataSource = result.data || [];\r\n        }\r\n\r\n        this.summaryData = result.summaryData || null;\r\n        // 本地排序模式：拿到数据后在前端排序\r\n        if (this.sortMode === \"local\") {\r\n          this.sortDataSourceInPlace();\r\n        }\r\n        this._pageInfo.total = result.total || 0;\r\n        // 取消跨页多选：查询后清空选中状态\r\n        if (this.showCheckbox) {\r\n          this.clearSelectedRows();\r\n        }\r\n      } catch (error) {\r\n        console.error(\"查询失败:\", error);\r\n        this.dataSource = [];\r\n        this._pageInfo.total = 0;\r\n        this.summaryData = null;\r\n      } finally {\r\n        this._loading = false;\r\n        this._selectedTableRow = null;\r\n      }\r\n    } else {\r\n      console.warn(\"未提供 _request 回调函数\");\r\n      this._loading = false;\r\n    }\r\n  }\r\n\r\n  // 触发列排序变更\r\n  onSortChange(sortKey: string, sortOrder: \"ascend\" | \"descend\" | null) {\r\n    // 单列排序：重置其它列；多列排序：保留其它列\r\n    if (!this.multipleSort) {\r\n      Object.keys(this._sortMap).forEach((key) => {\r\n        if (key !== sortKey) this._sortMap[key] = null;\r\n      });\r\n    }\r\n    this._sortMap[sortKey] = sortOrder;\r\n\r\n    // 维护优先级队列：有序列且非空 -> 置于末尾；为空 -> 移除\r\n    this._sortPriority = this._sortPriority.filter((k) => k !== sortKey);\r\n    if (sortOrder) {\r\n      this._sortPriority.push(sortKey);\r\n    }\r\n\r\n    if (this.sortMode === \"local\") {\r\n      this.sortDataSourceInPlace();\r\n    } else {\r\n      // 在线排序：重新请求\r\n      this.handleQuery();\r\n    }\r\n  }\r\n\r\n  getSortOrder(sortKey: string): \"ascend\" | \"descend\" | null {\r\n    return this._sortMap[sortKey] || null;\r\n  }\r\n\r\n  handleTableRowClick(data: any) {\r\n    this._selectedTableRow = data;\r\n    if (this.showCheckbox && !this.isRowDisabled(data)) {\r\n      // 先清空所有选中行\r\n      this._selectedRows = [];\r\n      const nextChecked = !this.isRowChecked(data);\r\n      this.toggleRowChecked(data, nextChecked);\r\n    }\r\n    this.onRowClick.emit(this._selectedTableRow);\r\n  }\r\n\r\n  handleTableRowDbClick(data: any) {\r\n    this._selectedTableRow = data;\r\n    this.onRowDbClick.emit(this._selectedTableRow);\r\n  }\r\n\r\n  handleColumnsSettingConfirm() {\r\n    this.queryDynamicColumns();\r\n  }\r\n\r\n  // 处理 autoComplete 输入事件（带防抖）\r\n  handleAutoCompleteInput(event: Event, column: ProTableColumn) {\r\n    const fieldKey = column.fieldProps?.name || column.prop;\r\n\r\n    // 如果该字段还没有防抖函数，创建一个\r\n    if (!this._autoCompleteDebounceMap.has(fieldKey)) {\r\n      const debouncedFn = debounce((evt: Event) => {\r\n        // 重新查找对应的 column，确保使用最新的配置\r\n        const currentColumn = this._searchFiledColumns.find(\r\n          (col) => (col.fieldProps?.name || col.prop) === fieldKey\r\n        );\r\n        if (currentColumn) {\r\n          this.executeAutoCompleteDataSource(evt, currentColumn);\r\n        }\r\n      }, 300); // 300ms 防抖延迟\r\n      this._autoCompleteDebounceMap.set(fieldKey, debouncedFn);\r\n    }\r\n\r\n    // 调用防抖函数\r\n    const debouncedFn = this._autoCompleteDebounceMap.get(fieldKey);\r\n    if (debouncedFn) {\r\n      debouncedFn(event);\r\n    }\r\n  }\r\n\r\n  // 获取 autoComplete 的数据源\r\n  getAutoCompleteDataSource(column: ProTableColumn): any[] {\r\n    const fieldKey = column.fieldProps?.name || column.prop;\r\n    return this._autoCompleteDataSources[fieldKey] || [];\r\n  }\r\n\r\n  getFieldProps(column: ProTableColumn): any {\r\n    return column.fieldProps;\r\n  }\r\n\r\n  // 获取指定名称的label模板\r\n  getLabelTemplate(name: string | undefined): TemplateRef<any> | null {\r\n    if (!name) return null;\r\n    return this.customTemplates.get(name) || null;\r\n  }\r\n\r\n  // 获取 form-item 的动态类名\r\n  getFormItemClassName(column: ProTableColumn): string {\r\n    const fieldName = this.getFieldProps(column).name || column.prop;\r\n    return `pro-table-${fieldName}-form-item`;\r\n  }\r\n}\r\n","<app-page-container\r\n  [title]=\"title\"\r\n  [showHeader]=\"showSearchBar\"\r\n  ngClass=\"pro-table-container\"\r\n>\r\n  <ng-template #header>\r\n    <app-table-search-bar\r\n      *ngIf=\"showSearchBar\"\r\n      [labelWidth]=\"labelWidth\"\r\n      [labelAlign]=\"labelAlign\"\r\n      [formItemWidth]=\"formItemWidth\"\r\n    >\r\n      <ng-template #leftContent>\r\n        <nz-form-item\r\n          *ngFor=\"let column of _searchFiledColumns\"\r\n          [ngClass]=\"getFormItemClassName(column)\"\r\n        >\r\n          <nz-form-label *ngIf=\"!getFieldProps(column).hideLabel\" nzNoColon>\r\n            <!-- 检查是否有自定义label模板 -->\r\n            <ng-container\r\n              *ngIf=\"\r\n                column.customLabelRender &&\r\n                  getLabelTemplate(column.customLabelRender);\r\n                else defaultLabel\r\n              \"\r\n            >\r\n              <ng-container\r\n                [ngTemplateOutlet]=\"getLabelTemplate(column.customLabelRender)\"\r\n                [ngTemplateOutletContext]=\"{\r\n                  $implicit: column,\r\n                  column: column,\r\n                  fieldProps: getFieldProps(column)\r\n                }\"\r\n              >\r\n              </ng-container>\r\n            </ng-container>\r\n            <ng-template #defaultLabel>\r\n              {{ getFieldProps(column).label || column.title }}\r\n            </ng-template>\r\n          </nz-form-label>\r\n          <nz-form-control *ngIf=\"column.valueType === 'input'\">\r\n            <input\r\n              nz-input\r\n              [name]=\"getFieldProps(column).name || column.prop\"\r\n              [placeholder]=\"getFieldProps(column).placeHolder\"\r\n              [disabled]=\"getFieldProps(column).disabled\"\r\n              [(ngModel)]=\"\r\n                _searchParams[getFieldProps(column).name || column.prop]\r\n              \"\r\n            />\r\n          </nz-form-control>\r\n          <nz-form-control *ngIf=\"column.valueType === 'inputPlate'\">\r\n            <app-plate-input\r\n              [name]=\"getFieldProps(column).name || column.prop\"\r\n              [(ngModel)]=\"\r\n                _searchParams[getFieldProps(column).name || column.prop]\r\n              \"\r\n            ></app-plate-input>\r\n          </nz-form-control>\r\n          <nz-form-control *ngIf=\"column.valueType === 'select'\">\r\n            <nz-select\r\n              [(ngModel)]=\"\r\n                _searchParams[getFieldProps(column).name || column.prop]\r\n              \"\r\n              [nzAllowClear]=\"getFieldProps(column).allowClear\"\r\n              [nzPlaceHolder]=\"getFieldProps(column).placeHolder\"\r\n              [name]=\"getFieldProps(column).name || column.prop\"\r\n              [nzOptions]=\"getFieldProps(column).options\"\r\n              [nzDisabled]=\"getFieldProps(column).disabled\"\r\n            >\r\n            </nz-select>\r\n          </nz-form-control>\r\n          <nz-form-control *ngIf=\"column.valueType === 'selectMultiple'\">\r\n            <nz-select\r\n              [(ngModel)]=\"\r\n                _searchParams[getFieldProps(column).name || column.prop]\r\n              \"\r\n              [nzAllowClear]=\"getFieldProps(column).allowClear\"\r\n              [nzPlaceHolder]=\"getFieldProps(column).placeHolder\"\r\n              [name]=\"getFieldProps(column).name || column.prop\"\r\n              [nzOptions]=\"getFieldProps(column).options\"\r\n              [nzDisabled]=\"getFieldProps(column).disabled\"\r\n              nzMode=\"multiple\"\r\n              [nzMaxTagCount]=\"2\"\r\n              [nzMaxTagPlaceholder]=\"nzMaxTagPlaceholder\"\r\n              [nzCustomTemplate]=\"defaultTemplate\"\r\n            >\r\n              <ng-template #nzMaxTagPlaceholder>\r\n                +\r\n                {{\r\n                  _searchParams[getFieldProps(column).name || column.prop]\r\n                    ?.length\r\n                }}\r\n              </ng-template>\r\n              <ng-template #defaultTemplate let-selected>\r\n                {{ selected.nzLabel.length > 4 ? selected.nzLabel.substring(0, 4) + '...' : selected.nzLabel }}\r\n              </ng-template>\r\n            </nz-select>\r\n          </nz-form-control>\r\n          <nz-form-control *ngIf=\"column.valueType === 'date'\">\r\n            <nz-date-picker\r\n              [nzShowTime]=\"getFieldProps(column).showTime\"\r\n              [nzFormat]=\"getFieldProps(column).format\"\r\n              [nzPlaceHolder]=\"getFieldProps(column).placeHolder\"\r\n              [nzAllowClear]=\"getFieldProps(column).allowClear\"\r\n              [nzDisabled]=\"getFieldProps(column).disabled\"\r\n              [(ngModel)]=\"\r\n                _searchParams[getFieldProps(column).name || column.prop]\r\n              \"\r\n              [nzMode]=\"getFieldProps(column).mode\"\r\n            ></nz-date-picker>\r\n          </nz-form-control>\r\n          <nz-form-control *ngIf=\"column.valueType === 'checkbox'\">\r\n            <nz-checkbox-group\r\n              [class]=\"\r\n                getFieldProps(column).noStyle\r\n                  ? 'pro-table-checkboxgroup-nostyle'\r\n                  : ''\r\n              \"\r\n              [(ngModel)]=\"getFieldProps(column).options\"\r\n              [nzDisabled]=\"getFieldProps(column).disabled\"\r\n              (ngModelChange)=\"\r\n                handleFieldCheckBoxChange(\r\n                  $event,\r\n                  getFieldProps(column).name || column.prop\r\n                )\r\n              \"\r\n            ></nz-checkbox-group>\r\n          </nz-form-control>\r\n          <nz-form-control *ngIf=\"column.valueType === 'autoComplete'\">\r\n            <input\r\n              nz-input\r\n              [(ngModel)]=\"\r\n                _searchParams[getFieldProps(column)?.name || column.prop]\r\n              \"\r\n              (input)=\"handleAutoCompleteInput($event, column)\"\r\n              [nzAutocomplete]=\"auto\"\r\n              [disabled]=\"getFieldProps(column)?.disabled\"\r\n              [placeholder]=\"getFieldProps(column)?.placeHolder\"\r\n            />\r\n            <nz-autocomplete\r\n              [nzBackfill]=\"getFieldProps(column).backFill\"\r\n              [nzDefaultActiveFirstOption]=\"\r\n                getFieldProps(column).defaultActiveFirstOption\r\n              \"\r\n              [nzWidth]=\"getFieldProps(column).width\"\r\n              #auto\r\n            >\r\n              <nz-auto-option\r\n                *ngFor=\"let option of getAutoCompleteDataSource(column)\"\r\n                [nzValue]=\"\r\n                  getFieldProps(column).returnFullData ? option : option.value\r\n                \"\r\n                [nzLabel]=\"option.label\"\r\n                [nzDisabled]=\"option.disabled\"\r\n              >\r\n                {{ option.label }}\r\n              </nz-auto-option>\r\n            </nz-autocomplete>\r\n          </nz-form-control>\r\n          <nz-form-control *ngIf=\"column.valueType === 'custom'\">\r\n            <app-dynamic-search-field\r\n              [component]=\"getFieldProps(column).component\"\r\n              [value]=\"_searchParams[getFieldProps(column).name || column.prop]\"\r\n              [props]=\"getFieldProps(column)\"\r\n              (valueChange)=\"\r\n                setFieldValue(getFieldProps(column).name || column.prop, $event)\r\n              \"\r\n            ></app-dynamic-search-field>\r\n          </nz-form-control>\r\n          <nz-form-control *ngIf=\"column.valueType === 'inputNumber'\">\r\n            <nz-input-number\r\n              [style.width]=\"'100%'\"\r\n              [(ngModel)]=\"\r\n                _searchParams[getFieldProps(column).name || column.prop]\r\n              \"\r\n              [nzPlaceHolder]=\"getFieldProps(column).placeHolder\"\r\n              [nzDisabled]=\"getFieldProps(column).disabled\"\r\n              [nzFormatter]=\"getFieldProps(column).formatterPercent\"\r\n              [nzParser]=\"getFieldProps(column).parserPercent\"\r\n            ></nz-input-number>\r\n          </nz-form-control>\r\n        </nz-form-item>\r\n      </ng-template>\r\n      <ng-template #actionTextBtn>\r\n        <nz-space [nzSize]=\"4\">\r\n          <ng-template nzSpaceItem *ngIf=\"showSearchBtn\">\r\n            <button nz-button nzType=\"primary\" (click)=\"handleSearch()\">\r\n              {{ confirmBtnText }}\r\n            </button>\r\n          </ng-template>\r\n          <ng-template nzSpaceItem *ngIf=\"showClearBtn\">\r\n            <button nz-button (click)=\"handleResetForm()\">\r\n              {{ clearBtnText }}\r\n            </button>\r\n          </ng-template>\r\n        </nz-space>\r\n      </ng-template>\r\n      <ng-template #actionImgBtn>\r\n        <nz-space>\r\n          <ng-container *ngTemplateOutlet=\"imgActionBarTpl\"></ng-container>\r\n          <ng-template nzSpaceItem class=\"setting-space-item\" *ngIf=\"showColumnSetting\">\r\n            <span nz-tooltip nzTooltipTitle=\"设置字段\">\r\n              <app-colmuns-setting\r\n                [columns]=\"columns\"\r\n                [selectedColumns]=\"_serverColumns\"\r\n                [tableName]=\"tableName\"\r\n                (afterConfirm)=\"handleColumnsSettingConfirm()\"\r\n              ></app-colmuns-setting>\r\n            </span>\r\n          </ng-template>\r\n        </nz-space>\r\n      </ng-template>\r\n    </app-table-search-bar>\r\n  </ng-template>\r\n\r\n  <ng-template #body>\r\n    <div class=\"mb-4\">\r\n      <ng-container *ngIf=\"showActionBar\">\r\n        <ng-container *ngTemplateOutlet=\"actionBarTpl\"></ng-container>\r\n      </ng-container>\r\n    </div>\r\n    <ng-container *ngIf=\"customTableRender\">\r\n      <ng-container *ngTemplateOutlet=\"customTableRender\"></ng-container>\r\n    </ng-container>\r\n    <nz-table\r\n      *ngIf=\"!customTableRender && _showTable\"\r\n      #dynamicTable\r\n      nzSize=\"small\"\r\n      nzShowSizeChanger\r\n      [nzBordered]=\"bordered\"\r\n      [nzOuterBordered]=\"outerBordered\"\r\n      [nzData]=\"dataSource\"\r\n      [nzPageIndex]=\"_pageInfo.pageIndex\"\r\n      [nzPageSize]=\"_pageInfo.pageSize\"\r\n      [nzTotal]=\"_pageInfo.total\"\r\n      [nzPageSizeOptions]=\"_pageInfo.pageSizeOptions\"\r\n      [nzShowPagination]=\"showPagination\"\r\n      [nzShowTotal]=\"totalTemplate\"\r\n      [nzLoading]=\"_loading\"\r\n      [nzFrontPagination]=\"frontPagination\"\r\n      [nzScroll]=\"scroll\"\r\n      (nzPageIndexChange)=\"handlePageIndexChange($event)\"\r\n      (nzPageSizeChange)=\"handlePageSizeChange($event)\"\r\n    >\r\n      <thead>\r\n        <tr>\r\n          <!-- 复选框列（当 showCheckbox=true 时显示） -->\r\n          <th\r\n            *ngIf=\"showCheckbox\"\r\n            [nzWidth]=\"'50px'\"\r\n            [nzAlign]=\"'center'\"\r\n            style=\"text-align: center\"\r\n            [(nzChecked)]=\"_checkedAll\"\r\n            [nzIndeterminate]=\"_indeterminate\"\r\n            (nzCheckedChange)=\"toggleCheckAll($event)\"\r\n            (click)=\"$event.stopPropagation()\"\r\n          ></th>\r\n          <th\r\n            *ngFor=\"let column of _columns\"\r\n            [nzWidth]=\"column.width\"\r\n            [nzAlign]=\"column.align\"\r\n            [nzLeft]=\"column.fixedLeft\"\r\n            [nzRight]=\"column.fixedRight\"\r\n            [nzShowSort]=\"!!column.sorter\"\r\n            [nzSortOrder]=\"getSortOrder(column.prop)\"\r\n            (nzSortOrderChange)=\"onSortChange(column.prop, $event)\"\r\n          >\r\n            {{ column.title }}\r\n          </th>\r\n        </tr>\r\n      </thead>\r\n\r\n      <tbody>\r\n        <tr\r\n          style=\"cursor: pointer\"\r\n          *ngFor=\"let data; let i = index; of: dynamicTable.data\"\r\n          [ngClass]=\"{\r\n            'ant-table-custom-row-selected': !!getTableRowChecked(data),\r\n            'ant-table-custom-row-even': i % 2 === 0,\r\n            'ant-table-custom-row-odd': i % 2 !== 0\r\n          }\"\r\n          (click)=\"handleTableRowClick(data)\"\r\n          (dblclick)=\"handleTableRowDbClick(data)\"\r\n        >\r\n          <!-- 复选框列（当 showCheckbox=true 时显示） -->\r\n          <td\r\n            *ngIf=\"showCheckbox\"\r\n            [nzAlign]=\"'center'\"\r\n            style=\"text-align: center; width: 50px\"\r\n            [(nzChecked)]=\"data.checked\"\r\n            [nzDisabled]=\"isRowDisabled(data)\"\r\n            (nzCheckedChange)=\"handleRowCheckedChange(data, $event)\"\r\n            (click)=\"$event.stopPropagation()\"\r\n          ></td>\r\n          <td\r\n            *ngFor=\"let column of _columns\"\r\n            [nzLeft]=\"column.fixedLeft\"\r\n            [nzRight]=\"column.fixedRight\"\r\n            [nzAlign]=\"column.align\"\r\n            [ngClass]=\"{\r\n              'pro-nowrap': true\r\n            }\"\r\n          >\r\n            <!-- 检查是否有自定义模板 -->\r\n            <ng-container\r\n              *ngIf=\"\r\n                column.customRender && getTemplate(column.customRender);\r\n                let template\r\n              \"\r\n            >\r\n              <ng-template\r\n                [ngTemplateOutlet]=\"template\"\r\n                [ngTemplateOutletContext]=\"{\r\n                  $implicit: data,\r\n                  data: data,\r\n                  column: column,\r\n                  index: i,\r\n                  pageInfo: _pageInfo\r\n                }\"\r\n              >\r\n              </ng-template>\r\n            </ng-container>\r\n\r\n            <!-- 默认渲染逻辑 -->\r\n            <ng-container\r\n              *ngIf=\"!column.customRender || !getTemplate(column.customRender)\"\r\n            >\r\n              <ng-container *ngIf=\"column.ellipsis\">\r\n                <div\r\n                  class=\"pro-ellipsis\"\r\n                  [title]=\"data[column.prop]\"\r\n                  [ngStyle]=\"{\r\n                    width: 'calc(' + column.width + ' - 25px)'\r\n                  }\"\r\n                >\r\n                  {{ data[column.prop] }}\r\n                </div>\r\n              </ng-container>\r\n              <ng-container *ngIf=\"!column.ellipsis\">\r\n                {{ data[column.prop] }}\r\n              </ng-container>\r\n            </ng-container>\r\n          </td>\r\n        </tr>\r\n        <tr *ngIf=\"summaryData && _pageInfo.total > 0\">\r\n          <!-- 汇总行的复选框列（当 showCheckbox=true 时显示，但为空） -->\r\n          <td\r\n            *ngIf=\"showCheckbox\"\r\n            style=\"font-weight: bold; border-right: 1px solid #e8e8e8\"\r\n          ></td>\r\n          <td\r\n            *ngFor=\"let column; let i = index; of: _columns\"\r\n            [nzLeft]=\"column.fixedLeft\"\r\n            [nzRight]=\"column.fixedRight\"\r\n            style=\"font-weight: bold; border-right: 1px solid #e8e8e8\"\r\n            [nzAlign]=\"column.align\"\r\n          >\r\n            <span *ngIf=\"i === 0\">总计</span>\r\n            <ng-container *ngIf=\"i !== 0 && column.summary\">\r\n              {{\r\n                column.summary?.format\r\n                  ? column.summary?.format(\r\n                      summaryData[column.summary?.name || column.prop]\r\n                    )\r\n                  : summaryData[column.summary?.name || column.prop]\r\n              }}\r\n            </ng-container>\r\n          </td>\r\n        </tr>\r\n      </tbody>\r\n      <ng-template #totalTemplate let-total\r\n        >共 {{ _pageInfo.total }} 条记录</ng-template\r\n      >\r\n    </nz-table>\r\n  </ng-template>\r\n</app-page-container>\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pro-table.component.js","sourceRoot":"","sources":["../../../../pro-table/src/lib/pro-table.component.ts","../../../../pro-table/src/lib/pro-table.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  AfterContentInit,\r\n  Component,\r\n  ContentChild,\r\n  ContentChildren,\r\n  EventEmitter,\r\n  HostListener,\r\n  Inject,\r\n  Input,\r\n  OnInit,\r\n  Optional,\r\n  Output,\r\n  QueryList,\r\n  TemplateRef,\r\n} from \"@angular/core\";\r\nimport { cloneDeep, hasIn, isNil, debounce, isEqual } from \"lodash-es\";\r\nimport { PRO_TABLE_DEFAULT_COLUMN, PRO_TABLE_DEFAULT_PROPS } from \"./constants\";\r\nimport {\r\n  AutoCompleteFieldProps,\r\n  CheckboxFieldProps,\r\n  OptionsType,\r\n  ProTableColumn,\r\n  ProTablePageInfo,\r\n  ProTableRequestResult,\r\n  ProTableValuesChange,\r\n  SelectFieldProps,\r\n} from \"./type\";\r\nimport { PRO_TABLE_COLUMN_REMOTE, ProTableRemoteColumnService } from \"./tokens\";\r\nimport { isObservable, lastValueFrom } from 'rxjs';\r\n\r\n@Component({\r\n  selector: \"app-pro-table\",\r\n  templateUrl: \"./pro-table.component.html\",\r\n  styleUrls: [\"./pro-table.component.less\"],\r\n})\r\nexport class ProTableComponent implements OnInit, AfterContentInit {\r\n  @Input() showSearchBtn: boolean = true;\r\n\r\n  @Input() showClearBtn: boolean = true;\r\n\r\n  @Input() title: string | null = null;\r\n\r\n  @Input() tableName: string = \"\";\r\n\r\n  @Input() multiRow: boolean = false;\r\n\r\n  @Input() columns: ProTableColumn[] = [];\r\n\r\n  @Input() showSearchBar: boolean = true;\r\n\r\n  @Input() showActionBar: boolean = true;\r\n\r\n  @Input() confirmBtnText: string = \"查询\";\r\n\r\n  @Input() clearBtnText: string = \"清空\";\r\n\r\n  @Input() labelWidth: string = \"90px\";\r\n\r\n  @Input() labelAlign: string = \"right\";\r\n\r\n  @Input() formItemWidth: string = \"330px\";\r\n\r\n  @Input() dataSource: any[] = [];\r\n\r\n  @Input() bordered: boolean = true;\r\n\r\n  @Input() outerBordered: boolean = true;\r\n\r\n  @Input() showPagination: boolean = true;\r\n\r\n  @Input() frontPagination: boolean = false;\r\n\r\n  @Input() scroll: { x?: string | number; y?: string | number } | null = null;\r\n\r\n  @Input() request: (params: any) => Promise<ProTableRequestResult>;\r\n\r\n  @Input() summaryData: Record<string, any> | null = null;\r\n\r\n  // 排序模式：local 本地排序；server 在线排序（提交给接口）\r\n  @Input() sortMode: \"local\" | \"server\" = \"local\";\r\n\r\n  @Input() showColumnSetting: boolean = false;\r\n\r\n  // 是否开启多列排序（默认单列）\r\n  @Input() multipleSort: boolean = false;\r\n\r\n  @Input() showCheckbox: boolean = false;\r\n\r\n  // 判断行是否禁用的函数\r\n  @Input() rowDisabled: (data: any) => boolean = () => false;\r\n\r\n  @Input() rerenderOnResize: boolean = true;\r\n\r\n  // 是否自动触发请求\r\n  @Input() autoTriggerRequest: boolean = true;\r\n\r\n  @Input() customTableRender?: TemplateRef<any>;\r\n\r\n  @Output() onRowClick = new EventEmitter<any>();\r\n\r\n  @Output() onRowDbClick = new EventEmitter<any>();\r\n\r\n  @Output() onValuesChange = new EventEmitter<ProTableValuesChange>();\r\n\r\n  @Output() onResetFormBeforeReload = new EventEmitter<any>();\r\n\r\n  @ContentChild(\"actionBar\") actionBarTpl!: TemplateRef<any>;\r\n\r\n  @ContentChild(\"ImgActionBar\") imgActionBarTpl!: TemplateRef<any>;\r\n\r\n  @ContentChildren(TemplateRef) allTemplates!: QueryList<TemplateRef<any>>;\r\n\r\n  private _savedSearchParams: any = {};\r\n\r\n  // 存储所有自定义模板的引用\r\n  private customTemplates = new Map<string, TemplateRef<any>>();\r\n\r\n  // 记录各列排序状态：'ascend' | 'descend' | null\r\n\r\n  private _sortMap: Record<string, \"ascend\" | \"descend\" | null> = {};\r\n\r\n  // 记录多列排序的优先级（后设置的优先）\r\n  private _sortPriority: string[] = [];\r\n\r\n  // 存储每个 autoComplete 字段的防抖函数\r\n  private _autoCompleteDebounceMap: Map<string, (event: Event) => void> =\r\n    new Map();\r\n\r\n  // 仅在初始化时运行列配置预检查，避免后续调用重复触发\r\n  private _preCheckDone: boolean = false;\r\n\r\n  _columns: ProTableColumn[] = [];\r\n\r\n  // 筛选表单数据存储\r\n  _searchParams: any = {};\r\n\r\n  // 筛选表单list渲染数据\r\n  _searchFiledColumns: ProTableColumn[] = [];\r\n\r\n  _pageInfo: ProTablePageInfo = {\r\n    pageIndex: 1,\r\n    pageSize: 15,\r\n    total: 100,\r\n    pageSizeOptions: [10, 15, 20, 50, 100, 500, 1000],\r\n  };\r\n\r\n  _loading: boolean = false;\r\n\r\n  _selectedTableRow: any = null;\r\n\r\n  // 选中的行数据（用于复选框选择）- 保留用于兼容性\r\n  _selectedRows: any[] = [];\r\n\r\n  // 全选状态\r\n  _checkedAll: boolean = false;\r\n\r\n  // 半选状态（部分选中）\r\n  _indeterminate: boolean = false;\r\n\r\n  // 远程columns\r\n  _serverColumns: ProTableColumn[] = [];\r\n\r\n  // 存储 autoComplete 字段的数据源\r\n  _autoCompleteDataSources: Record<string, any[]> = {};\r\n\r\n  // 控制表格显示状态，用于重新挂载\r\n  _showTable: boolean = true;\r\n\r\n  // 防抖定时器，用于窗口大小调整\r\n  private resizeDebounce: any;\r\n\r\n  @HostListener(\"window:resize\")\r\n  onWindowResize() {\r\n    if (!this.rerenderOnResize) return;\r\n\r\n    if (this.resizeDebounce) {\r\n      clearTimeout(this.resizeDebounce);\r\n    }\r\n\r\n    this.resizeDebounce = setTimeout(() => {\r\n      // 通过 ngIf 重新挂载表格\r\n      this._showTable = false;\r\n      setTimeout(() => {\r\n        this._showTable = true;\r\n      }, 0);\r\n    }, 150);\r\n  }\r\n  constructor(\r\n    @Optional()\r\n    @Inject(PRO_TABLE_COLUMN_REMOTE)\r\n    private columnRemote: ProTableRemoteColumnService | null\r\n  ) {}\r\n\r\n  private async fetchRemoteColumns() {\r\n    if (!this.columnRemote?.getCol || !this.tableName) {\r\n      return null;\r\n    }\r\n    try {\r\n      const res = await this.columnRemote.getCol(this.tableName, this.multiRow);\r\n      return res;\r\n    } catch (error) {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  private async persistRemoteColumns(columns: any[]) {\r\n    if (!this.columnRemote?.setCol || !this.tableName) {\r\n      return null;\r\n    }\r\n    try {\r\n      const result = this.columnRemote.setCol(\r\n        this.tableName,\r\n        columns,\r\n        this.multiRow\r\n      );\r\n      if (result && isObservable(result)) {\r\n        return await lastValueFrom(result);\r\n      }\r\n      return result;\r\n    } catch (error) {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  async ngOnInit(): Promise<void> {\r\n    this._searchParams = {};\r\n    this.formateInnerColumns(this.columns);\r\n    await this.setSearchParams(this.columns);\r\n\r\n    // 使用 Proxy 包装 _searchParams，拦截表单项值变化并向外发出事件\r\n    this._searchParams = this.createSearchParamsProxy(this._searchParams);\r\n    if (this.autoTriggerRequest) {\r\n      this.handleQuery();\r\n    }\r\n    this.queryDynamicColumns();\r\n  }\r\n\r\n  ngAfterContentInit() {\r\n    // 自动注册所有自定义模板\r\n    // 注意：此时所有 ContentChild 和 ContentChildren 都已初始化完成\r\n    this.autoRegisterTemplates();\r\n  }\r\n\r\n  private async preCheckServerColumns(): Promise<boolean> {\r\n    const res = await this.fetchRemoteColumns();\r\n    if (!res) return false;\r\n    const initColumns = this.columns\r\n      .filter((col) => !col.auxiliaryColumn)\r\n      .map((column) => {\r\n        return {\r\n          field: column.prop,\r\n          isShow: !column.hideInTable, // 默认全部显示\r\n          header: column.title,\r\n          sortName: column.sortName || null,\r\n        };\r\n      });\r\n    if (res.code === 0) {\r\n      const serverColumns = Array.isArray(res?.data?.tabColumn)\r\n        ? res.data.tabColumn\r\n        : [];\r\n      // 以远程数据为主：保留远程顺序与显示状态，仅做字段结构合并（新增字段追加、删除字段过滤）\r\n      const merged = this.mergeServerColumnsWithInit(serverColumns, initColumns);\r\n      if (!isEqual(serverColumns, merged)) {\r\n        const persistRes = await this.persistRemoteColumns(merged);\r\n        if (persistRes) {\r\n          this.queryDynamicColumns();\r\n        }\r\n        return false;\r\n      }\r\n      return true;\r\n    } else if (res.code === 10) {\r\n      // code === 10 表示未初始化，需要继续执行后续逻辑\r\n      return true;\r\n    } else {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  private mergeServerColumnsWithInit(\r\n    serverColumns: any[],\r\n    initColumns: Array<{\r\n      field: string;\r\n      isShow: boolean;\r\n      header: string;\r\n      sortName?: string | null;\r\n    }>\r\n  ) {\r\n    const initByField = new Map<\r\n      string,\r\n      { field: string; isShow: boolean; header: string; sortName?: string | null }\r\n    >();\r\n    initColumns.forEach((c) => initByField.set(c.field, c));\r\n\r\n    const merged: any[] = [];\r\n    const seen = new Set<string>();\r\n\r\n    // 1) 保留远程顺序与显示状态；同步 header/sortName；过滤掉前端已不存在的 field\r\n    serverColumns.forEach((sc: any) => {\r\n      const field = sc?.field;\r\n      if (!field || !initByField.has(field) || seen.has(field)) return;\r\n      const init = initByField.get(field)!;\r\n      merged.push({\r\n        ...sc,\r\n        header: init.header,\r\n        sortName: init.sortName ?? null,\r\n      });\r\n      seen.add(field);\r\n    });\r\n\r\n    // 2) 新增字段（远程不存在）追加到末尾，默认显示用 initColumns 的 isShow\r\n    initColumns.forEach((ic) => {\r\n      if (seen.has(ic.field)) return;\r\n      merged.push({\r\n        field: ic.field,\r\n        isShow: ic.isShow,\r\n        header: ic.header,\r\n        sortName: ic.sortName ?? null,\r\n      });\r\n      seen.add(ic.field);\r\n    });\r\n\r\n    return merged;\r\n  }\r\n\r\n  private async queryDynamicColumns() {\r\n    if (!this.tableName || !this.columnRemote) return;\r\n    if (!this._preCheckDone) {\r\n      const checkResult = await this.preCheckServerColumns();\r\n      this._preCheckDone = true;\r\n      if (!checkResult) return;\r\n    }\r\n    const res = await this.fetchRemoteColumns();\r\n    if (!res) return;\r\n    if (res.code === 0) {\r\n      const _tabColumn = res.data.tabColumn.map((item) => {\r\n        return {\r\n          title: item.header,\r\n          prop: item.field,\r\n          sortName: item.sortName,\r\n          hideInTable: !item.isShow,\r\n        };\r\n      });\r\n      this._serverColumns = _tabColumn;\r\n      this.updateTableColumns(_tabColumn);\r\n    } else if (res.code === 10) {\r\n      // 如果未设置接口返回，需要默认调用一次修改函数初始化数据\r\n      const initColumns = this.columns\r\n        .filter((col) => !col.auxiliaryColumn)\r\n        .map((column) => {\r\n          return {\r\n            field: column.prop,\r\n            isShow: true, // 默认全部显示\r\n            header: column.title,\r\n            sortName: column.sortName || null,\r\n          };\r\n        });\r\n\r\n      // 调用修改接口初始化数据\r\n      const initRes = await this.persistRemoteColumns(initColumns);\r\n      if (initRes) {\r\n        this.queryDynamicColumns();\r\n      }\r\n    }\r\n  }\r\n\r\n  private formateInnerColumns(columns: ProTableColumn[]) {\r\n    this._columns = columns\r\n      .filter((item) => !item.hideInTable)\r\n      .map((item) => {\r\n        return { ...PRO_TABLE_DEFAULT_COLUMN, ...item } as ProTableColumn;\r\n      });\r\n  }\r\n\r\n  // 自动注册模板的方法\r\n  private autoRegisterTemplates() {\r\n    // 获取所有模板\r\n    const allTemplatesArray = this.allTemplates.toArray();\r\n\r\n    // 获取所有需要自定义模板的列\r\n    const columnsWithCustomRender = this._columns.filter(\r\n      (col) => col.customRender\r\n    );\r\n\r\n    // 获取所有需要自定义label模板的列（使用原始columns，确保顺序正确）\r\n    const columnsWithCustomLabel = this.columns.filter(\r\n      (col) => col.customLabelRender\r\n    );\r\n\r\n    // 计算需要的模板总数\r\n    const customRenderCount = columnsWithCustomRender.length;\r\n    const totalNeededTemplates = customRenderCount + columnsWithCustomLabel.length;\r\n\r\n    // 识别并排除特殊模板（actionBar 和 imgActionBar）\r\n    const specialTemplateIndices = new Set<number>();\r\n    \r\n    // 尝试找到 actionBarTpl 在 allTemplatesArray 中的位置\r\n    if (this.actionBarTpl) {\r\n      const actionBarIndex = this.findTemplateIndex(allTemplatesArray, this.actionBarTpl);\r\n      if (actionBarIndex !== -1) {\r\n        specialTemplateIndices.add(actionBarIndex);\r\n      }\r\n    }\r\n    \r\n    // 尝试找到 imgActionBarTpl 在 allTemplatesArray 中的位置\r\n    if (this.imgActionBarTpl) {\r\n      const imgActionBarIndex = this.findTemplateIndex(allTemplatesArray, this.imgActionBarTpl);\r\n      if (imgActionBarIndex !== -1) {\r\n        specialTemplateIndices.add(imgActionBarIndex);\r\n      }\r\n    }\r\n\r\n    // 如果无法通过引用找到特殊模板，使用备用策略\r\n    // 备用策略：假设最后的模板是特殊模板\r\n    const specialTemplateCount = (this.actionBarTpl ? 1 : 0) + (this.imgActionBarTpl ? 1 : 0);\r\n    if (specialTemplateIndices.size === 0 && specialTemplateCount > 0) {\r\n      for (let i = allTemplatesArray.length - specialTemplateCount; i < allTemplatesArray.length; i++) {\r\n        specialTemplateIndices.add(i);\r\n      }\r\n    }\r\n\r\n    // 提取列模板（排除特殊模板）\r\n    const columnTemplates: TemplateRef<any>[] = [];\r\n    allTemplatesArray.forEach((tpl, index) => {\r\n      if (!specialTemplateIndices.has(index)) {\r\n        columnTemplates.push(tpl);\r\n      }\r\n    });\r\n\r\n    // 验证模板数量\r\n    if (columnTemplates.length !== totalNeededTemplates) {\r\n      console.warn(\r\n        `ProTable: 模板数量不匹配！需要 ${totalNeededTemplates} 个列模板，实际有 ${columnTemplates.length} 个。请检查 customRender 和 customLabelRender 配置。`\r\n      );\r\n    }\r\n\r\n    // 注册自定义渲染模板\r\n    columnsWithCustomRender.forEach((column, index) => {\r\n      const templateName = column.customRender!;\r\n      if (index < columnTemplates.length) {\r\n        this.customTemplates.set(templateName, columnTemplates[index]);\r\n      } else {\r\n        console.error(`ProTable: 未找到模板 \"${templateName}\"，索引 ${index} 超出范围`);\r\n      }\r\n    });\r\n\r\n    // 注册自定义label模板（从 customRenderCount 之后开始）\r\n    columnsWithCustomLabel.forEach((column, index) => {\r\n      const templateName = column.customLabelRender!;\r\n      const templateIndex = customRenderCount + index;\r\n      if (templateIndex < columnTemplates.length) {\r\n        this.customTemplates.set(templateName, columnTemplates[templateIndex]);\r\n      } else {\r\n        console.error(`ProTable: 未找到label模板 \"${templateName}\"，索引 ${templateIndex} 超出范围`);\r\n      }\r\n    });\r\n  }\r\n\r\n  // 尝试在数组中找到模板的索引（使用多种比较方式）\r\n  private findTemplateIndex(templates: TemplateRef<any>[], target: TemplateRef<any>): number {\r\n    // 方法1：引用相等性\r\n    let index = templates.indexOf(target);\r\n    if (index !== -1) return index;\r\n\r\n    // 方法2：通过 elementRef 比较\r\n    try {\r\n      const targetElementRef = (target as any).elementRef;\r\n      if (targetElementRef) {\r\n        for (let i = 0; i < templates.length; i++) {\r\n          const tplElementRef = (templates[i] as any).elementRef;\r\n          if (tplElementRef === targetElementRef) {\r\n            return i;\r\n          }\r\n        }\r\n      }\r\n    } catch (e) {\r\n      // 忽略错误\r\n    }\r\n\r\n    // 方法3：通过 Angular 内部属性比较\r\n    try {\r\n      const targetContainer = (target as any)._declarationTContainer;\r\n      if (targetContainer) {\r\n        for (let i = 0; i < templates.length; i++) {\r\n          const tplContainer = (templates[i] as any)._declarationTContainer;\r\n          if (tplContainer === targetContainer) {\r\n            return i;\r\n          }\r\n        }\r\n      }\r\n    } catch (e) {\r\n      // 忽略错误\r\n    }\r\n\r\n    return -1;\r\n  }\r\n\r\n  // 设置筛选表单默认属性\r\n  private setSearchFormDefaultProp(columns: ProTableColumn[]) {\r\n    columns.forEach((item) => {\r\n      if (item.valueType) {\r\n        if (item.fieldProps) {\r\n          item.fieldProps = {\r\n            ...PRO_TABLE_DEFAULT_PROPS[item.valueType],\r\n            ...item.fieldProps,\r\n          };\r\n        } else {\r\n          item.fieldProps = { ...PRO_TABLE_DEFAULT_PROPS[item.valueType] };\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n  // 动态设置Options\r\n  private setSelectRequest(columns: ProTableColumn[]) {\r\n    columns.map(async (item) => {\r\n      if (item.fieldProps && hasIn(item.fieldProps, \"request\")) {\r\n        try {\r\n          const options = await (\r\n            item.fieldProps as SelectFieldProps\r\n          ).request?.();\r\n          (item.fieldProps as SelectFieldProps).options = options;\r\n        } catch (error) {\r\n          (item.fieldProps as SelectFieldProps).options = [];\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n  private async setSearchParams(columns: ProTableColumn[]) {\r\n    this._searchFiledColumns = [];\r\n    columns\r\n      .filter((item) => {\r\n        const flag = !item.hideInSearch && item.valueType;\r\n        if (flag) {\r\n          this._searchFiledColumns.push(cloneDeep(item));\r\n        }\r\n        return flag;\r\n      })\r\n      .forEach((column) => {\r\n        const key = column.fieldProps?.name || column.prop;\r\n        let defaultValue = PRO_TABLE_DEFAULT_PROPS[column.valueType].value;\r\n\r\n        // 对于checkbox类型，从options中找出checked为true的项作为默认值\r\n        if (column.valueType === \"checkbox\") {\r\n          const checkedValues = (column.fieldProps?.options || [])\r\n            .filter((opt: OptionsType) => opt.checked)\r\n            .map((opt: OptionsType) => opt.value);\r\n          this._searchParams[key] =\r\n            checkedValues.length > 0 ? checkedValues : defaultValue;\r\n        } else {\r\n          this._searchParams[key] = column.fieldProps?.value || defaultValue;\r\n        }\r\n\r\n        // 初始化 autoComplete 数据源\r\n        if (column.valueType === \"autoComplete\") {\r\n          this._autoCompleteDataSources[key] = [];\r\n        }\r\n      });\r\n\r\n    // 根据列的 order 字段进行排序，未设置 order 的放在最后\r\n    this._searchFiledColumns.sort((a: any, b: any) => {\r\n      const aOrder = isNil(a?.order) ? Number.MAX_SAFE_INTEGER : a.order;\r\n      const bOrder = isNil(b?.order) ? Number.MAX_SAFE_INTEGER : b.order;\r\n      if (aOrder === bOrder) return 0;\r\n      return aOrder - bOrder;\r\n    });\r\n\r\n    this.setSearchFormDefaultProp(this._searchFiledColumns);\r\n\r\n    // 并发加载所有需要异步获取的选项\r\n    this.setSelectRequest(this._searchFiledColumns);\r\n  }\r\n\r\n  private updateTableColumns(injectColumns: ProTableColumn[]) {\r\n    // 1. 使用最原始的columns作为数据源，确保辅助列完全不受影响\r\n    const originalColumns = cloneDeep(this.columns);\r\n\r\n    // 2. 处理字段映射（如果提供了fields参数）\r\n    let processedInjectColumns = injectColumns;\r\n\r\n    // 3. 分离辅助列和非辅助列（使用原始数据）\r\n    const nonAuxiliaryColumns = originalColumns.filter(\r\n      (col) => !col.auxiliaryColumn\r\n    );\r\n\r\n    // 4. 按照injectColumns的顺序重新排列非辅助列\r\n    const reorderedNonAuxiliaryColumns: ProTableColumn[] = [];\r\n    const remainingNonAuxiliaryColumns = [...nonAuxiliaryColumns]; // 复制一份用于查找和移除\r\n\r\n    processedInjectColumns.forEach((injectCol) => {\r\n      // 查找非辅助列中对应的下标\r\n      const existingColIndex = remainingNonAuxiliaryColumns.findIndex(\r\n        (col) => col.prop === injectCol.prop\r\n      );\r\n      if (existingColIndex !== -1) {\r\n        // 如果找到相同列，用injectColumns中的属性覆盖原始columns中的属性\r\n        const existingCol = remainingNonAuxiliaryColumns[existingColIndex];\r\n\r\n        const updatedCol = { ...existingCol, ...injectCol };\r\n        reorderedNonAuxiliaryColumns.push(updatedCol);\r\n        // 从剩余数组中移除，避免重复\r\n        remainingNonAuxiliaryColumns.splice(existingColIndex, 1);\r\n      } else {\r\n        // 如果没找到对应的列，直接添加injectColumns中的列\r\n        reorderedNonAuxiliaryColumns.push(injectCol);\r\n      }\r\n    });\r\n\r\n    // 5. 处理剩余的原始columns中的非辅助列（在injectColumns中未出现的列）\r\n    // 这些列应该被隐藏（设置hideInTable为true）\r\n    remainingNonAuxiliaryColumns.forEach((remainingCol) => {\r\n      const hiddenCol = { ...remainingCol, hideInTable: true };\r\n      reorderedNonAuxiliaryColumns.push(hiddenCol);\r\n    });\r\n\r\n    // 6. 按照原始columns的顺序重新组合：保持辅助列的原始位置和属性\r\n    const finalColumns: ProTableColumn[] = [];\r\n    let nonAuxiliaryIndex = 0;\r\n    let auxiliaryIndex = 0;\r\n\r\n    originalColumns.forEach((originalCol) => {\r\n      if (originalCol.auxiliaryColumn) {\r\n        // 如果是辅助列，使用原始列数据，完全不进行任何修改\r\n        finalColumns.push(originalCol);\r\n        auxiliaryIndex++;\r\n      } else {\r\n        // 如果是非辅助列，使用重新排序后的列，但保留原始列的所有属性\r\n        const reorderedCol = reorderedNonAuxiliaryColumns[nonAuxiliaryIndex];\r\n        if (reorderedCol) {\r\n          // 合并原始列和重新排序后的列，确保保留所有原始属性\r\n          const mergedCol = { ...originalCol, ...reorderedCol };\r\n          finalColumns.push(mergedCol);\r\n        } else {\r\n          // 如果重新排序后的列不存在，使用原始列\r\n          finalColumns.push(originalCol);\r\n        }\r\n        nonAuxiliaryIndex++;\r\n      }\r\n    });\r\n    this.formateInnerColumns(finalColumns);\r\n  }\r\n\r\n  // 通过 Proxy 监听 _searchParams 的属性变更\r\n  private createSearchParamsProxy(target: any) {\r\n    const self = this;\r\n    const handler: ProxyHandler<any> = {\r\n      set(obj: any, prop: string | symbol, value: any) {\r\n        const key = String(prop);\r\n        const oldVal = obj[key];\r\n        if (oldVal === value) {\r\n          obj[key] = value;\r\n          return true;\r\n        }\r\n        obj[key] = value;\r\n        try {\r\n          self.onValuesChange.emit({\r\n            key,\r\n            value,\r\n            params: self.getSearchParams(),\r\n          });\r\n        } catch (e) {}\r\n        return true;\r\n      },\r\n    };\r\n    return new Proxy(target, handler);\r\n  }\r\n\r\n  private clearEmptySearchParams() {\r\n    const cloneSearchParams = cloneDeep(this._searchParams);\r\n    return cloneSearchParams;\r\n  }\r\n\r\n  private buildServerSortPayload() {\r\n    // 构建激活排序集合（按优先级从低到高，末尾优先）\r\n    const activeKeys = this._sortPriority.filter((k) => !!this._sortMap[k]);\r\n    if (activeKeys.length === 0) return null;\r\n    const sorts = activeKeys.map((field) => {\r\n      // 查找对应的列配置，优先使用sortName字段\r\n      const column = this._columns.find((col) => col.prop === field);\r\n      const sortField = column?.sortName || field;\r\n      return {\r\n        field: sortField,\r\n        order: this._sortMap[field]!,\r\n      };\r\n    });\r\n    if (this.multipleSort) {\r\n      return sorts; // 以数组形式提交多列排序\r\n    }\r\n    const [first] = sorts;\r\n    return first; // 兼容单列结构 { field, order }\r\n  }\r\n\r\n  private sortDataSourceInPlace() {\r\n    if (!Array.isArray(this.dataSource) || this.dataSource.length === 0) return;\r\n    const activeKeys = this._sortPriority.filter((k) => !!this._sortMap[k]);\r\n    if (activeKeys.length === 0) return;\r\n\r\n    // 复制一份优先级，从前到后优先级从低到高（最后设置的字段优先）\r\n    const keysInPriority = [...activeKeys];\r\n    this.dataSource.sort((a: any, b: any) => {\r\n      for (let i = keysInPriority.length - 1; i >= 0; i--) {\r\n        const field = keysInPriority[i];\r\n        const order = this._sortMap[field]!;\r\n        const av = a?.[field];\r\n        const bv = b?.[field];\r\n        const cmp = this.compareValues(av, bv);\r\n        if (cmp !== 0) return order === \"ascend\" ? cmp : -cmp;\r\n      }\r\n      return 0;\r\n    });\r\n  }\r\n\r\n  private compareValues(aVal: any, bVal: any): number {\r\n    if (aVal == null && bVal == null) return 0;\r\n    if (aVal == null) return -1;\r\n    if (bVal == null) return 1;\r\n    if (aVal instanceof Date && bVal instanceof Date) {\r\n      return aVal.getTime() - bVal.getTime();\r\n    }\r\n    if (typeof aVal === \"boolean\" && typeof bVal === \"boolean\") {\r\n      return aVal === bVal ? 0 : aVal ? 1 : -1;\r\n    }\r\n    if (typeof aVal === \"number\" && typeof bVal === \"number\") {\r\n      return aVal - bVal;\r\n    }\r\n    if (typeof aVal === \"string\" && typeof bVal === \"string\") {\r\n      return aVal.localeCompare(bVal);\r\n    }\r\n    const aNum = Number(aVal);\r\n    const bNum = Number(bVal);\r\n    if (!isNaN(aNum) && !isNaN(bNum)) return aNum - bNum;\r\n    return String(aVal).localeCompare(String(bVal));\r\n  }\r\n\r\n  // 执行 autoComplete 数据源查询（实际执行逻辑）\r\n  private executeAutoCompleteDataSource(event: Event, column: ProTableColumn) {\r\n    const fieldKey = column.fieldProps?.name || column.prop;\r\n\r\n    if (\r\n      (column.fieldProps as AutoCompleteFieldProps).dataSource &&\r\n      typeof (column.fieldProps as AutoCompleteFieldProps).dataSource ===\r\n        \"function\"\r\n    ) {\r\n      try {\r\n        const result = (column.fieldProps as AutoCompleteFieldProps).dataSource(\r\n          event\r\n        );\r\n        // 如果返回的是 Promise，处理异步结果\r\n        if (result instanceof Promise) {\r\n          result\r\n            .then((data) => {\r\n              this._autoCompleteDataSources[fieldKey] = data || [];\r\n            })\r\n            .catch((error) => {\r\n              console.error(\"AutoComplete dataSource error:\", error);\r\n              this._autoCompleteDataSources[fieldKey] = [];\r\n            });\r\n        } else {\r\n          // 同步返回结果\r\n          this._autoCompleteDataSources[fieldKey] = result || [];\r\n        }\r\n      } catch (error) {\r\n        console.error(\"AutoComplete dataSource error:\", error);\r\n        this._autoCompleteDataSources[fieldKey] = [];\r\n      }\r\n    }\r\n  }\r\n\r\n  public getSearchParams(options?: {\r\n    useSaved?: boolean; // 使用最近一次查询提交的参数，默认为 false；false 为当前表单值\r\n  }): any {\r\n    const { useSaved = false } = options || {};\r\n    const rawParams = useSaved ? this._savedSearchParams : this._searchParams;\r\n    const params = cloneDeep(rawParams || {});\r\n\r\n    return {\r\n      params,\r\n      pageInfo: {\r\n        pageIndex: this._pageInfo.pageIndex,\r\n        pageSize: this._pageInfo.pageSize,\r\n      },\r\n      // 在线排序模式：把排序对象提交给接口\r\n      ...(this.sortMode === \"server\"\r\n        ? { sort: this.buildServerSortPayload() }\r\n        : {}),\r\n    };\r\n  }\r\n\r\n  public reload(afterDelete?: boolean) {\r\n    this.handleQuery(afterDelete);\r\n  }\r\n\r\n  public setFieldsValue(fields: Record<string, any>) {\r\n    Object.keys(fields).forEach((k) => {\r\n      this._searchParams[k] = fields[k]; // 保留 Proxy，逐项赋值触发拦截\r\n    });\r\n  }\r\n\r\n  public setFieldValue(key: string, value: any) {\r\n    this._searchParams[key] = value;\r\n  }\r\n\r\n  public clearSelectedRow() {\r\n    this._selectedTableRow = null;\r\n  }\r\n\r\n  public async setColumns(\r\n    columns: ProTableColumn[],\r\n    options?: {\r\n      reload?: boolean; // 是否重新加载数据，默认为 false\r\n    }\r\n  ): Promise<void> {\r\n    // 更新 columns 输入属性\r\n    this.columns = cloneDeep(columns);\r\n\r\n    // 重新格式化内部列\r\n    this.formateInnerColumns(this.columns);\r\n\r\n    // 重新设置搜索参数（异步操作）\r\n    // 先清空旧的搜索参数，避免旧数据残留\r\n    this._searchParams = {};\r\n    await this.setSearchParams(this.columns);\r\n\r\n    // 重新创建 Proxy，确保表单项值变化能正常触发事件\r\n    this._searchParams = this.createSearchParamsProxy(this._searchParams);\r\n\r\n    // 重新注册模板（如果组件已经初始化完成）\r\n    if (this.allTemplates) {\r\n      this.autoRegisterTemplates();\r\n    }\r\n\r\n    // 如果设置了 reload 选项为 true，则重新查询数据\r\n    if (options?.reload === true) {\r\n      this.handleQuery();\r\n    }\r\n  }\r\n\r\n  public getSelectedRowData<T = any>(): T {\r\n    return this._selectedTableRow;\r\n  }\r\n\r\n  public getCheckedRows<T = any>(): T[] {\r\n    if (!this.showCheckbox) {\r\n      return [];\r\n    }\r\n    // 返回当前数据源中所有 checked 为 true 的项\r\n    // 注意：如果需要获取所有页的选中项，需要遍历所有数据源或使用 _selectedRowIds\r\n    return this.dataSource.filter((row) => row.checked === true) as T[];\r\n  }\r\n\r\n  // 获取指定名称的模板\r\n  getTemplate(name: string | undefined): TemplateRef<any> | null {\r\n    if (!name) return null;\r\n    return this.customTemplates.get(name) || null;\r\n  }\r\n\r\n  getToolTipTextValue(column: ProTableColumn, data: any): string {\r\n    const key =\r\n      column.customRender && this.getTemplate(column.customRender)\r\n        ? \"\"\r\n        : column.ellipsis\r\n        ? column.prop\r\n        : \"\";\r\n    return !key ? \"\" : data[key];\r\n  }\r\n\r\n  getTableRowChecked(data: any) {\r\n    // 启用复选框时：行高亮应与复选框选中状态一致（支持多选）\r\n    if (this.showCheckbox) {\r\n      return this.isRowChecked(data);\r\n    }\r\n    // 未启用复选框时：仍然使用单选行高亮\r\n    if (!this._selectedTableRow) return false;\r\n    return JSON.stringify(this._selectedTableRow) === JSON.stringify(data);\r\n  }\r\n\r\n  // 检查行是否被禁用\r\n  isRowDisabled(data: any): boolean {\r\n    if (!this.showCheckbox) return false;\r\n    return this.rowDisabled ? this.rowDisabled(data) : false;\r\n  }\r\n\r\n  // 检查行是否被复选框选中（数据驱动模式）\r\n  isRowChecked(data: any): boolean {\r\n    if (!this.showCheckbox) return false;\r\n    // 直接读取数据对象的 checked 属性\r\n    return data.checked === true;\r\n  }\r\n\r\n  // 切换行的选中状态（数据驱动模式，保留用于兼容）\r\n  toggleRowChecked(data: any, checked: boolean, event?: Event) {\r\n    if (event) {\r\n      event.stopPropagation(); // 阻止事件冒泡，避免触发行点击\r\n    }\r\n    // 如果行被禁用，不允许切换选中状态\r\n    if (this.isRowDisabled(data)) {\r\n      return;\r\n    }\r\n\r\n    // 直接设置数据对象的 checked 属性\r\n    data.checked = checked;\r\n\r\n    // 同步更新 _selectedRows（用于兼容性）\r\n    const index = this._selectedRows.findIndex((row) =>\r\n      this.isSameRow(row, data)\r\n    );\r\n    if (checked) {\r\n      if (index === -1) {\r\n        this._selectedRows.push(data);\r\n      }\r\n      // 勾选复选框时同步设置高亮选中行\r\n      this._selectedTableRow = data;\r\n    } else {\r\n      if (index > -1) {\r\n        this._selectedRows.splice(index, 1);\r\n      }\r\n      // 若当前高亮行为该行，则取消高亮\r\n      if (\r\n        this._selectedTableRow &&\r\n        this.isSameRow(this._selectedTableRow, data)\r\n      ) {\r\n        this._selectedTableRow = null;\r\n      }\r\n    }\r\n\r\n    this.updateCheckAllStatus();\r\n  }\r\n\r\n  // 更新全选状态（数据驱动模式）\r\n  updateCheckAllStatus() {\r\n    if (!this.showCheckbox || !Array.isArray(this.dataSource)) {\r\n      this._checkedAll = false;\r\n      this._indeterminate = false;\r\n      return;\r\n    }\r\n    // 只计算可用的行（未禁用的行）\r\n    const availableRows = this.dataSource.filter(\r\n      (row) => !this.isRowDisabled(row)\r\n    );\r\n    // 基于数据对象的 checked 属性计算\r\n    const checkedCount = availableRows.filter(\r\n      (row) => row.checked === true\r\n    ).length;\r\n    const totalCount = availableRows.length;\r\n    this._checkedAll =\r\n      totalCount > 0 && checkedCount > 0 && checkedCount === totalCount;\r\n    this._indeterminate = checkedCount > 0 && checkedCount < totalCount;\r\n  }\r\n\r\n  // 全选/取消全选（数据驱动模式）\r\n  toggleCheckAll(checked: boolean, event?: Event) {\r\n    if (event) {\r\n      event.stopPropagation();\r\n    }\r\n\r\n    // 只处理可用的行（未禁用的行）\r\n    const availableRows = this.dataSource.filter(\r\n      (row) => !this.isRowDisabled(row)\r\n    );\r\n\r\n    // 批量设置 checked 属性\r\n    availableRows.forEach((row) => {\r\n      row.checked = checked;\r\n    });\r\n\r\n    // 同步更新 _selectedRows（用于兼容性）\r\n    if (checked) {\r\n      this._selectedRows = [...availableRows];\r\n      // 同步设置高亮选中行为第一条可选数据\r\n      this._selectedTableRow =\r\n        availableRows.length > 0 ? availableRows[0] : null;\r\n    } else {\r\n      this._selectedRows = [];\r\n      // 取消高亮\r\n      this._selectedTableRow = null;\r\n    }\r\n\r\n    this.updateCheckAllStatus();\r\n  }\r\n\r\n  // 获取选中的行数据（保留用于兼容性）\r\n  getSelectedRows(): any[] {\r\n    return this.getCheckedRows();\r\n  }\r\n\r\n  // 处理行 checkbox 变化事件（数据驱动模式）\r\n  handleRowCheckedChange(data: any, checked: boolean): void {\r\n    if (this.isRowDisabled(data)) {\r\n      return;\r\n    }\r\n\r\n    // 数据对象的 checked 属性已经通过双向绑定自动更新\r\n    // 这里只需要同步更新 _selectedRows\r\n\r\n    // 同步更新 _selectedRows（用于兼容性）\r\n    const index = this._selectedRows.findIndex((row) =>\r\n      this.isSameRow(row, data)\r\n    );\r\n    if (checked) {\r\n      if (index === -1) {\r\n        this._selectedRows.push(data);\r\n      }\r\n      // 勾选复选框时同步设置高亮选中行\r\n      this._selectedTableRow = data;\r\n    } else {\r\n      if (index > -1) {\r\n        this._selectedRows.splice(index, 1);\r\n      }\r\n      // 若当前高亮行为该行，则取消高亮\r\n      if (\r\n        this._selectedTableRow &&\r\n        this.isSameRow(this._selectedTableRow, data)\r\n      ) {\r\n        this._selectedTableRow = null;\r\n      }\r\n    }\r\n\r\n    // 更新全选状态\r\n    this.updateCheckAllStatus();\r\n  }\r\n\r\n  // 刷新全选状态（用于其他场景）\r\n  refreshCheckAllStatus(): void {\r\n    this.updateCheckAllStatus();\r\n  }\r\n\r\n  // 获取行的唯一标识（用于跨页选中）\r\n  private getRowId(data: any): string | number | undefined {\r\n    return data.id ?? data.key ?? undefined;\r\n  }\r\n\r\n  // 判断两行是否为同一行\r\n  private isSameRow(row1: any, row2: any): boolean {\r\n    const id1 = this.getRowId(row1);\r\n    const id2 = this.getRowId(row2);\r\n\r\n    if (id1 !== undefined && id2 !== undefined) {\r\n      return id1 === id2;\r\n    }\r\n\r\n    // fallback 到 JSON 比较\r\n    return JSON.stringify(row1) === JSON.stringify(row2);\r\n  }\r\n\r\n  // 清空选中的行（数据驱动模式）\r\n  clearSelectedRows() {\r\n    // 清空当前数据源中所有项的 checked 状态\r\n    if (Array.isArray(this.dataSource)) {\r\n      this.dataSource.forEach((row) => {\r\n        row.checked = false;\r\n      });\r\n    }\r\n\r\n    this._selectedRows = [];\r\n    this._checkedAll = false;\r\n    this._indeterminate = false;\r\n    this._selectedTableRow = null;\r\n  }\r\n\r\n  handleFieldCheckBoxChange(checkBoxOptions: OptionsType[], key: string) {\r\n    this.setFieldsValue({\r\n      [key]: checkBoxOptions\r\n        .filter((item) => item.checked)\r\n        .map((item) => item.value),\r\n    });\r\n  }\r\n\r\n  handleSearch() {\r\n    this._savedSearchParams = this.clearEmptySearchParams();\r\n    this._pageInfo.pageIndex = 1;\r\n    this.handleQuery();\r\n  }\r\n\r\n  handleResetForm() {\r\n    Object.keys(this._searchParams).forEach((key) => {\r\n      const targetColumn = this._searchFiledColumns.find((item) => {\r\n        return (item.fieldProps?.name || item.prop) === key;\r\n      });\r\n\r\n      // 对于checkbox类型，需要特殊处理默认值\r\n      if (targetColumn?.valueType === \"checkbox\") {\r\n        // 从原始columns配置中获取初始配置，以确保使用正确的默认值\r\n        const originalColumn = this.columns.find((item) => {\r\n          return (item.fieldProps?.name || item.prop) === key;\r\n        });\r\n\r\n        // 从原始options中找出checked为true的项作为默认值\r\n        const originalFieldProps = originalColumn?.fieldProps as\r\n          | CheckboxFieldProps\r\n          | undefined;\r\n        const checkedValues = (originalFieldProps?.options || [])\r\n          .filter((opt: OptionsType) => opt.checked)\r\n          .map((opt: OptionsType) => opt.value);\r\n        const defaultValue =\r\n          checkedValues.length > 0\r\n            ? checkedValues\r\n            : PRO_TABLE_DEFAULT_PROPS[targetColumn.valueType].value;\r\n\r\n        this._searchParams[key] = defaultValue;\r\n\r\n        // 根据默认值恢复options的checked状态，使用原始options的结构\r\n        const defaultValues = Array.isArray(defaultValue) ? defaultValue : [];\r\n        const originalOptions = originalFieldProps?.options || [];\r\n        const targetFieldProps = targetColumn.fieldProps as CheckboxFieldProps;\r\n        targetFieldProps.options = originalOptions.map((item: OptionsType) => {\r\n          return {\r\n            ...item,\r\n            checked: defaultValues.includes(item.value),\r\n          };\r\n        });\r\n      } else {\r\n        this._searchParams[key] = targetColumn?.fieldProps\r\n          ? targetColumn?.fieldProps.value ||\r\n            PRO_TABLE_DEFAULT_PROPS[targetColumn.valueType].value\r\n          : PRO_TABLE_DEFAULT_PROPS[targetColumn.valueType].value;\r\n      }\r\n    });\r\n\r\n    this._savedSearchParams = {};\r\n    this._pageInfo.pageIndex = 1;\r\n    this.onResetFormBeforeReload.emit();\r\n    this.handleQuery();\r\n  }\r\n\r\n  handlePageIndexChange(pageIndex: number) {\r\n    this._pageInfo.pageIndex = pageIndex;\r\n    this.handleQuery();\r\n  }\r\n\r\n  handlePageSizeChange(pageSize: any) {\r\n    this._pageInfo.pageSize = pageSize;\r\n    this._pageInfo.pageIndex = 1;\r\n    this.handleQuery();\r\n  }\r\n\r\n  async handleQuery(afterDelete?: boolean) {\r\n    // 删除后刷新且当前页仅剩一条记录时，若不在第一页则先回退一页\r\n    if (\r\n      afterDelete &&\r\n      Array.isArray(this.dataSource) &&\r\n      this.dataSource.length === 1 &&\r\n      this._pageInfo.pageIndex > 1\r\n    ) {\r\n      this._pageInfo.pageIndex = this._pageInfo.pageIndex - 1;\r\n    }\r\n\r\n    this._loading = true;\r\n    if (this.request) {\r\n      try {\r\n        const result = await this.request({\r\n          params: this.clearEmptySearchParams(),\r\n          pageInfo: {\r\n            pageIndex: this._pageInfo.pageIndex,\r\n            pageSize: this._pageInfo.pageSize,\r\n          },\r\n          // 在线排序模式：把排序对象提交给接口\r\n          ...(this.sortMode === \"server\"\r\n            ? { sort: this.buildServerSortPayload() }\r\n            : {}),\r\n        });\r\n\r\n        // 查询后默认不保留跨页选中状态：每次返回的数据均初始化为未选中\r\n        if (this.showCheckbox) {\r\n          this.dataSource = (result.data || []).map((item) => {\r\n            return {\r\n              ...item,\r\n              checked: false,\r\n            };\r\n          });\r\n        } else {\r\n          this.dataSource = result.data || [];\r\n        }\r\n\r\n        this.summaryData = result.summaryData || null;\r\n        // 本地排序模式：拿到数据后在前端排序\r\n        if (this.sortMode === \"local\") {\r\n          this.sortDataSourceInPlace();\r\n        }\r\n        this._pageInfo.total = result.total || 0;\r\n        // 取消跨页多选：查询后清空选中状态\r\n        if (this.showCheckbox) {\r\n          this.clearSelectedRows();\r\n        }\r\n      } catch (error) {\r\n        console.error(\"查询失败:\", error);\r\n        this.dataSource = [];\r\n        this._pageInfo.total = 0;\r\n        this.summaryData = null;\r\n      } finally {\r\n        this._loading = false;\r\n        this._selectedTableRow = null;\r\n      }\r\n    } else {\r\n      console.warn(\"未提供 _request 回调函数\");\r\n      this._loading = false;\r\n    }\r\n  }\r\n\r\n  // 触发列排序变更\r\n  onSortChange(sortKey: string, sortOrder: \"ascend\" | \"descend\" | null) {\r\n    // 单列排序：重置其它列；多列排序：保留其它列\r\n    if (!this.multipleSort) {\r\n      Object.keys(this._sortMap).forEach((key) => {\r\n        if (key !== sortKey) this._sortMap[key] = null;\r\n      });\r\n    }\r\n    this._sortMap[sortKey] = sortOrder;\r\n\r\n    // 维护优先级队列：有序列且非空 -> 置于末尾；为空 -> 移除\r\n    this._sortPriority = this._sortPriority.filter((k) => k !== sortKey);\r\n    if (sortOrder) {\r\n      this._sortPriority.push(sortKey);\r\n    }\r\n\r\n    if (this.sortMode === \"local\") {\r\n      this.sortDataSourceInPlace();\r\n    } else {\r\n      // 在线排序：重新请求\r\n      this.handleQuery();\r\n    }\r\n  }\r\n\r\n  getSortOrder(sortKey: string): \"ascend\" | \"descend\" | null {\r\n    return this._sortMap[sortKey] || null;\r\n  }\r\n\r\n  handleTableRowClick(data: any) {\r\n    this._selectedTableRow = data;\r\n    if (this.showCheckbox && !this.isRowDisabled(data)) {\r\n      // 先清空所有选中行\r\n      this._selectedRows = [];\r\n      const nextChecked = !this.isRowChecked(data);\r\n      this.toggleRowChecked(data, nextChecked);\r\n    }\r\n    this.onRowClick.emit(this._selectedTableRow);\r\n  }\r\n\r\n  handleTableRowDbClick(data: any) {\r\n    this._selectedTableRow = data;\r\n    this.onRowDbClick.emit(this._selectedTableRow);\r\n  }\r\n\r\n  handleColumnsSettingConfirm() {\r\n    this.queryDynamicColumns();\r\n  }\r\n\r\n  // 处理 autoComplete 输入事件（带防抖）\r\n  handleAutoCompleteInput(event: Event, column: ProTableColumn) {\r\n    const fieldKey = column.fieldProps?.name || column.prop;\r\n\r\n    // 如果该字段还没有防抖函数，创建一个\r\n    if (!this._autoCompleteDebounceMap.has(fieldKey)) {\r\n      const debouncedFn = debounce((evt: Event) => {\r\n        // 重新查找对应的 column，确保使用最新的配置\r\n        const currentColumn = this._searchFiledColumns.find(\r\n          (col) => (col.fieldProps?.name || col.prop) === fieldKey\r\n        );\r\n        if (currentColumn) {\r\n          this.executeAutoCompleteDataSource(evt, currentColumn);\r\n        }\r\n      }, 300); // 300ms 防抖延迟\r\n      this._autoCompleteDebounceMap.set(fieldKey, debouncedFn);\r\n    }\r\n\r\n    // 调用防抖函数\r\n    const debouncedFn = this._autoCompleteDebounceMap.get(fieldKey);\r\n    if (debouncedFn) {\r\n      debouncedFn(event);\r\n    }\r\n  }\r\n\r\n  // 获取 autoComplete 的数据源\r\n  getAutoCompleteDataSource(column: ProTableColumn): any[] {\r\n    const fieldKey = column.fieldProps?.name || column.prop;\r\n    return this._autoCompleteDataSources[fieldKey] || [];\r\n  }\r\n\r\n  getFieldProps(column: ProTableColumn): any {\r\n    return column.fieldProps;\r\n  }\r\n\r\n  // 获取指定名称的label模板\r\n  getLabelTemplate(name: string | undefined): TemplateRef<any> | null {\r\n    if (!name) return null;\r\n    return this.customTemplates.get(name) || null;\r\n  }\r\n\r\n  // 获取 form-item 的动态类名\r\n  getFormItemClassName(column: ProTableColumn): string {\r\n    const fieldName = this.getFieldProps(column).name || column.prop;\r\n    return `pro-table-${fieldName}-form-item`;\r\n  }\r\n}\r\n","<app-page-container\r\n  [title]=\"title\"\r\n  [showHeader]=\"showSearchBar\"\r\n  ngClass=\"pro-table-container\"\r\n>\r\n  <ng-template #header>\r\n    <app-table-search-bar\r\n      *ngIf=\"showSearchBar\"\r\n      [labelWidth]=\"labelWidth\"\r\n      [labelAlign]=\"labelAlign\"\r\n      [formItemWidth]=\"formItemWidth\"\r\n    >\r\n      <ng-template #leftContent>\r\n        <nz-form-item\r\n          *ngFor=\"let column of _searchFiledColumns\"\r\n          [ngClass]=\"getFormItemClassName(column)\"\r\n        >\r\n          <nz-form-label *ngIf=\"!getFieldProps(column).hideLabel\" nzNoColon>\r\n            <!-- 检查是否有自定义label模板 -->\r\n            <ng-container\r\n              *ngIf=\"\r\n                column.customLabelRender &&\r\n                  getLabelTemplate(column.customLabelRender);\r\n                else defaultLabel\r\n              \"\r\n            >\r\n              <ng-container\r\n                [ngTemplateOutlet]=\"getLabelTemplate(column.customLabelRender)\"\r\n                [ngTemplateOutletContext]=\"{\r\n                  $implicit: column,\r\n                  column: column,\r\n                  fieldProps: getFieldProps(column)\r\n                }\"\r\n              >\r\n              </ng-container>\r\n            </ng-container>\r\n            <ng-template #defaultLabel>\r\n              {{ getFieldProps(column).label || column.title }}\r\n            </ng-template>\r\n          </nz-form-label>\r\n          <nz-form-control *ngIf=\"column.valueType === 'input'\">\r\n            <input\r\n              nz-input\r\n              [name]=\"getFieldProps(column).name || column.prop\"\r\n              [placeholder]=\"getFieldProps(column).placeHolder\"\r\n              [disabled]=\"getFieldProps(column).disabled\"\r\n              [(ngModel)]=\"\r\n                _searchParams[getFieldProps(column).name || column.prop]\r\n              \"\r\n            />\r\n          </nz-form-control>\r\n          <nz-form-control *ngIf=\"column.valueType === 'inputPlate'\">\r\n            <app-plate-input\r\n              [name]=\"getFieldProps(column).name || column.prop\"\r\n              [(ngModel)]=\"\r\n                _searchParams[getFieldProps(column).name || column.prop]\r\n              \"\r\n            ></app-plate-input>\r\n          </nz-form-control>\r\n          <nz-form-control *ngIf=\"column.valueType === 'select'\">\r\n            <nz-select\r\n              [(ngModel)]=\"\r\n                _searchParams[getFieldProps(column).name || column.prop]\r\n              \"\r\n              [nzAllowClear]=\"getFieldProps(column).allowClear\"\r\n              [nzPlaceHolder]=\"getFieldProps(column).placeHolder\"\r\n              [name]=\"getFieldProps(column).name || column.prop\"\r\n              [nzOptions]=\"getFieldProps(column).options\"\r\n              [nzDisabled]=\"getFieldProps(column).disabled\"\r\n            >\r\n            </nz-select>\r\n          </nz-form-control>\r\n          <nz-form-control *ngIf=\"column.valueType === 'selectMultiple'\">\r\n            <nz-select\r\n              [(ngModel)]=\"\r\n                _searchParams[getFieldProps(column).name || column.prop]\r\n              \"\r\n              [nzAllowClear]=\"getFieldProps(column).allowClear\"\r\n              [nzPlaceHolder]=\"getFieldProps(column).placeHolder\"\r\n              [name]=\"getFieldProps(column).name || column.prop\"\r\n              [nzOptions]=\"getFieldProps(column).options\"\r\n              [nzDisabled]=\"getFieldProps(column).disabled\"\r\n              nzMode=\"multiple\"\r\n              [nzMaxTagCount]=\"2\"\r\n              [nzMaxTagPlaceholder]=\"nzMaxTagPlaceholder\"\r\n              [nzCustomTemplate]=\"defaultTemplate\"\r\n            >\r\n              <ng-template #nzMaxTagPlaceholder>\r\n                +\r\n                {{\r\n                  _searchParams[getFieldProps(column).name || column.prop]\r\n                    ?.length\r\n                }}\r\n              </ng-template>\r\n              <ng-template #defaultTemplate let-selected>\r\n                {{ selected.nzLabel.length > 4 ? selected.nzLabel.substring(0, 4) + '...' : selected.nzLabel }}\r\n              </ng-template>\r\n            </nz-select>\r\n          </nz-form-control>\r\n          <nz-form-control *ngIf=\"column.valueType === 'date'\">\r\n            <nz-date-picker\r\n              [nzShowTime]=\"getFieldProps(column).showTime\"\r\n              [nzFormat]=\"getFieldProps(column).format\"\r\n              [nzPlaceHolder]=\"getFieldProps(column).placeHolder\"\r\n              [nzAllowClear]=\"getFieldProps(column).allowClear\"\r\n              [nzDisabled]=\"getFieldProps(column).disabled\"\r\n              [(ngModel)]=\"\r\n                _searchParams[getFieldProps(column).name || column.prop]\r\n              \"\r\n              [nzMode]=\"getFieldProps(column).mode\"\r\n            ></nz-date-picker>\r\n          </nz-form-control>\r\n          <nz-form-control *ngIf=\"column.valueType === 'checkbox'\">\r\n            <nz-checkbox-group\r\n              [class]=\"\r\n                getFieldProps(column).noStyle\r\n                  ? 'pro-table-checkboxgroup-nostyle'\r\n                  : ''\r\n              \"\r\n              [(ngModel)]=\"getFieldProps(column).options\"\r\n              [nzDisabled]=\"getFieldProps(column).disabled\"\r\n              (ngModelChange)=\"\r\n                handleFieldCheckBoxChange(\r\n                  $event,\r\n                  getFieldProps(column).name || column.prop\r\n                )\r\n              \"\r\n            ></nz-checkbox-group>\r\n          </nz-form-control>\r\n          <nz-form-control *ngIf=\"column.valueType === 'autoComplete'\">\r\n            <input\r\n              nz-input\r\n              [(ngModel)]=\"\r\n                _searchParams[getFieldProps(column)?.name || column.prop]\r\n              \"\r\n              (input)=\"handleAutoCompleteInput($event, column)\"\r\n              [nzAutocomplete]=\"auto\"\r\n              [disabled]=\"getFieldProps(column)?.disabled\"\r\n              [placeholder]=\"getFieldProps(column)?.placeHolder\"\r\n            />\r\n            <nz-autocomplete\r\n              [nzBackfill]=\"getFieldProps(column).backFill\"\r\n              [nzDefaultActiveFirstOption]=\"\r\n                getFieldProps(column).defaultActiveFirstOption\r\n              \"\r\n              [nzWidth]=\"getFieldProps(column).width\"\r\n              #auto\r\n            >\r\n              <nz-auto-option\r\n                *ngFor=\"let option of getAutoCompleteDataSource(column)\"\r\n                [nzValue]=\"\r\n                  getFieldProps(column).returnFullData ? option : option.value\r\n                \"\r\n                [nzLabel]=\"option.label\"\r\n                [nzDisabled]=\"option.disabled\"\r\n              >\r\n                {{ option.label }}\r\n              </nz-auto-option>\r\n            </nz-autocomplete>\r\n          </nz-form-control>\r\n          <nz-form-control *ngIf=\"column.valueType === 'custom'\">\r\n            <app-dynamic-search-field\r\n              [component]=\"getFieldProps(column).component\"\r\n              [value]=\"_searchParams[getFieldProps(column).name || column.prop]\"\r\n              [props]=\"getFieldProps(column)\"\r\n              (valueChange)=\"\r\n                setFieldValue(getFieldProps(column).name || column.prop, $event)\r\n              \"\r\n            ></app-dynamic-search-field>\r\n          </nz-form-control>\r\n          <nz-form-control *ngIf=\"column.valueType === 'inputNumber'\">\r\n            <nz-input-number\r\n              [style.width]=\"'100%'\"\r\n              [(ngModel)]=\"\r\n                _searchParams[getFieldProps(column).name || column.prop]\r\n              \"\r\n              [nzPlaceHolder]=\"getFieldProps(column).placeHolder\"\r\n              [nzDisabled]=\"getFieldProps(column).disabled\"\r\n              [nzFormatter]=\"getFieldProps(column).formatterPercent\"\r\n              [nzParser]=\"getFieldProps(column).parserPercent\"\r\n            ></nz-input-number>\r\n          </nz-form-control>\r\n        </nz-form-item>\r\n      </ng-template>\r\n      <ng-template #actionTextBtn>\r\n        <nz-space [nzSize]=\"4\">\r\n          <ng-template nzSpaceItem *ngIf=\"showSearchBtn\">\r\n            <button nz-button nzType=\"primary\" (click)=\"handleSearch()\">\r\n              {{ confirmBtnText }}\r\n            </button>\r\n          </ng-template>\r\n          <ng-template nzSpaceItem *ngIf=\"showClearBtn\">\r\n            <button nz-button (click)=\"handleResetForm()\">\r\n              {{ clearBtnText }}\r\n            </button>\r\n          </ng-template>\r\n        </nz-space>\r\n      </ng-template>\r\n      <ng-template #actionImgBtn>\r\n        <nz-space>\r\n          <ng-container *ngTemplateOutlet=\"imgActionBarTpl\"></ng-container>\r\n          <ng-template nzSpaceItem class=\"setting-space-item\" *ngIf=\"showColumnSetting\">\r\n            <span nz-tooltip nzTooltipTitle=\"设置字段\">\r\n              <app-colmuns-setting\r\n                [columns]=\"columns\"\r\n                [selectedColumns]=\"_serverColumns\"\r\n                [tableName]=\"tableName\"\r\n                (afterConfirm)=\"handleColumnsSettingConfirm()\"\r\n              ></app-colmuns-setting>\r\n            </span>\r\n          </ng-template>\r\n        </nz-space>\r\n      </ng-template>\r\n    </app-table-search-bar>\r\n  </ng-template>\r\n\r\n  <ng-template #body>\r\n    <div class=\"mb-4\">\r\n      <ng-container *ngIf=\"showActionBar\">\r\n        <ng-container *ngTemplateOutlet=\"actionBarTpl\"></ng-container>\r\n      </ng-container>\r\n    </div>\r\n    <ng-container *ngIf=\"customTableRender\">\r\n      <ng-container *ngTemplateOutlet=\"customTableRender\"></ng-container>\r\n    </ng-container>\r\n    <nz-table\r\n      *ngIf=\"!customTableRender && _showTable\"\r\n      #dynamicTable\r\n      nzSize=\"small\"\r\n      nzShowSizeChanger\r\n      [nzBordered]=\"bordered\"\r\n      [nzOuterBordered]=\"outerBordered\"\r\n      [nzData]=\"dataSource\"\r\n      [nzPageIndex]=\"_pageInfo.pageIndex\"\r\n      [nzPageSize]=\"_pageInfo.pageSize\"\r\n      [nzTotal]=\"_pageInfo.total\"\r\n      [nzPageSizeOptions]=\"_pageInfo.pageSizeOptions\"\r\n      [nzShowPagination]=\"showPagination\"\r\n      [nzShowTotal]=\"totalTemplate\"\r\n      [nzLoading]=\"_loading\"\r\n      [nzFrontPagination]=\"frontPagination\"\r\n      [nzScroll]=\"scroll\"\r\n      (nzPageIndexChange)=\"handlePageIndexChange($event)\"\r\n      (nzPageSizeChange)=\"handlePageSizeChange($event)\"\r\n    >\r\n      <thead>\r\n        <tr>\r\n          <!-- 复选框列（当 showCheckbox=true 时显示） -->\r\n          <th\r\n            *ngIf=\"showCheckbox\"\r\n            [nzWidth]=\"'50px'\"\r\n            [nzAlign]=\"'center'\"\r\n            style=\"text-align: center\"\r\n            [(nzChecked)]=\"_checkedAll\"\r\n            [nzIndeterminate]=\"_indeterminate\"\r\n            (nzCheckedChange)=\"toggleCheckAll($event)\"\r\n            (click)=\"$event.stopPropagation()\"\r\n          ></th>\r\n          <th\r\n            *ngFor=\"let column of _columns\"\r\n            [nzWidth]=\"column.width\"\r\n            [nzAlign]=\"column.align\"\r\n            [nzLeft]=\"column.fixedLeft\"\r\n            [nzRight]=\"column.fixedRight\"\r\n            [nzShowSort]=\"!!column.sorter\"\r\n            [nzSortOrder]=\"getSortOrder(column.prop)\"\r\n            (nzSortOrderChange)=\"onSortChange(column.prop, $event)\"\r\n          >\r\n            {{ column.title }}\r\n          </th>\r\n        </tr>\r\n      </thead>\r\n\r\n      <tbody>\r\n        <tr\r\n          style=\"cursor: pointer\"\r\n          *ngFor=\"let data; let i = index; of: dynamicTable.data\"\r\n          [ngClass]=\"{\r\n            'ant-table-custom-row-selected': !!getTableRowChecked(data),\r\n            'ant-table-custom-row-even': i % 2 === 0,\r\n            'ant-table-custom-row-odd': i % 2 !== 0\r\n          }\"\r\n          (click)=\"handleTableRowClick(data)\"\r\n          (dblclick)=\"handleTableRowDbClick(data)\"\r\n        >\r\n          <!-- 复选框列（当 showCheckbox=true 时显示） -->\r\n          <td\r\n            *ngIf=\"showCheckbox\"\r\n            [nzAlign]=\"'center'\"\r\n            style=\"text-align: center; width: 50px\"\r\n            [(nzChecked)]=\"data.checked\"\r\n            [nzDisabled]=\"isRowDisabled(data)\"\r\n            (nzCheckedChange)=\"handleRowCheckedChange(data, $event)\"\r\n            (click)=\"$event.stopPropagation()\"\r\n          ></td>\r\n          <td\r\n            *ngFor=\"let column of _columns\"\r\n            [nzLeft]=\"column.fixedLeft\"\r\n            [nzRight]=\"column.fixedRight\"\r\n            [nzAlign]=\"column.align\"\r\n            [ngClass]=\"{\r\n              'pro-nowrap': true\r\n            }\"\r\n          >\r\n            <!-- 检查是否有自定义模板 -->\r\n            <ng-container\r\n              *ngIf=\"\r\n                column.customRender && getTemplate(column.customRender);\r\n                let template\r\n              \"\r\n            >\r\n              <ng-template\r\n                [ngTemplateOutlet]=\"template\"\r\n                [ngTemplateOutletContext]=\"{\r\n                  $implicit: data,\r\n                  data: data,\r\n                  column: column,\r\n                  index: i,\r\n                  pageInfo: _pageInfo\r\n                }\"\r\n              >\r\n              </ng-template>\r\n            </ng-container>\r\n\r\n            <!-- 默认渲染逻辑 -->\r\n            <ng-container\r\n              *ngIf=\"!column.customRender || !getTemplate(column.customRender)\"\r\n            >\r\n              <ng-container *ngIf=\"column.ellipsis\">\r\n                <div\r\n                  class=\"pro-ellipsis\"\r\n                  [title]=\"data[column.prop]\"\r\n                  [ngStyle]=\"{\r\n                    width: 'calc(' + column.width + ' - 25px)'\r\n                  }\"\r\n                >\r\n                  {{ data[column.prop] }}\r\n                </div>\r\n              </ng-container>\r\n              <ng-container *ngIf=\"!column.ellipsis\">\r\n                {{ data[column.prop] }}\r\n              </ng-container>\r\n            </ng-container>\r\n          </td>\r\n        </tr>\r\n        <tr *ngIf=\"summaryData && _pageInfo.total > 0\">\r\n          <!-- 汇总行的复选框列（当 showCheckbox=true 时显示，但为空） -->\r\n          <td\r\n            *ngIf=\"showCheckbox\"\r\n            style=\"font-weight: bold; border-right: 1px solid #e8e8e8\"\r\n          ></td>\r\n          <td\r\n            *ngFor=\"let column; let i = index; of: _columns\"\r\n            [nzLeft]=\"column.fixedLeft\"\r\n            [nzRight]=\"column.fixedRight\"\r\n            style=\"font-weight: bold; border-right: 1px solid #e8e8e8\"\r\n            [nzAlign]=\"column.align\"\r\n          >\r\n            <span *ngIf=\"i === 0\">总计</span>\r\n            <ng-container *ngIf=\"i !== 0 && column.summary\">\r\n              {{\r\n                column.summary?.format\r\n                  ? column.summary?.format(\r\n                      summaryData[column.summary?.name || column.prop]\r\n                    )\r\n                  : summaryData[column.summary?.name || column.prop]\r\n              }}\r\n            </ng-container>\r\n          </td>\r\n        </tr>\r\n      </tbody>\r\n      <ng-template #totalTemplate let-total\r\n        >共 {{ _pageInfo.total }} 条记录</ng-template\r\n      >\r\n    </nz-table>\r\n  </ng-template>\r\n</app-page-container>\r\n"]}