@yibozhang/pro-table 16.1.1 → 16.1.2

package/fesm2022/yibozhang-pro-table.mjs

@@ -1,6 +1,6 @@
 import * as i0 from '@angular/core';
 import { InjectionToken, Component, Input, ContentChild, Directive, Optional, HostListener, forwardRef, Inject, EventEmitter, Output, ViewChild, ViewContainerRef, TemplateRef, ContentChildren, NgModule, Injectable } from '@angular/core';
-import { isEqual, hasIn, cloneDeep, isNil, debounce } from 'lodash-es';
+import { hasIn, cloneDeep, isNil, debounce } from 'lodash-es';
 import { isObservable, lastValueFrom } from 'rxjs';
 import * as i1 from '@angular/common';
 import { CommonModule } from '@angular/common';
@@ -753,8 +753,6 @@ class ProTableComponent {
     _sortPriority = [];
     // 存储每个 autoComplete 字段的防抖函数
     _autoCompleteDebounceMap = new Map();
-    // 仅在初始化时运行列配置预检查，避免后续调用重复触发
-    _preCheckDone = false;
     _columns = [];
     // 筛选表单数据存储
     _searchParams = {};
@@ -842,85 +840,9 @@ class ProTableComponent {
         // 注意：此时所有 ContentChild 和 ContentChildren 都已初始化完成
         this.autoRegisterTemplates();
     }
-    async preCheckServerColumns() {
-        const res = await this.fetchRemoteColumns();
-        if (!res)
-            return false;
-        const initColumns = this.columns
-            .filter((col) => !col.auxiliaryColumn)
-            .map((column) => {
-            return {
-                field: column.prop,
-                isShow: !column.hideInTable,
-                header: column.title,
-                sortName: column.sortName || null,
-            };
-        });
-        if (res.code === 0) {
-            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;
-            }
-            return true;
-        }
-        else if (res.code === 10) {
-            // code === 10 表示未初始化，需要继续执行后续逻辑
-            return true;
-        }
-        else {
-            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.forEach((ic) => {
-            const field = ic?.field;
-            if (!field || seen.has(field))
-                return;
-            merged.push({
-                field,
-                isShow: ic.isShow,
-                header: ic.header,
-                sortName: ic.sortName ?? null,
-            });
-            seen.add(field);
-        });
-        return merged;
-    }
     async queryDynamicColumns() {
         if (!this.tableName || !this.columnRemote)
             return;
-        if (!this._preCheckDone) {
-            const checkResult = await this.preCheckServerColumns();
-            this._preCheckDone = true;
-            if (!checkResult)
-                return;
-        }
         const res = await this.fetchRemoteColumns();
         if (!res)
             return;
@@ -933,22 +855,19 @@ class ProTableComponent {
                     hideInTable: !item.isShow,
                 };
             });
-            this._serverColumns = _tabColumn;
-            this.updateTableColumns(_tabColumn);
+            this._serverColumns = _tabColumn.filter((col) => this.columns.some((localCol) => localCol.prop === col.prop));
+            this.updateTableColumns(this._serverColumns);
         }
         else if (res.code === 10) {
             // 如果未设置接口返回，需要默认调用一次修改函数初始化数据
             const initColumns = this.columns
                 .filter((col) => !col.auxiliaryColumn)
-                .map((column) => {
-                return {
-                    field: column.prop,
-                    isShow: true,
-                    header: column.title,
-                    sortName: column.sortName || null,
-                };
-            });
-            // 调用修改接口初始化数据
+                .map((column) => ({
+                field: column.prop,
+                isShow: true,
+                header: column.title,
+                sortName: column.sortName || null,
+            }));
             const initRes = await this.persistRemoteColumns(initColumns);
             if (initRes) {
                 this.queryDynamicColumns();
@@ -1140,63 +1059,21 @@ class ProTableComponent {
         this.setSelectRequest(this._searchFiledColumns);
     }
     updateTableColumns(injectColumns) {
-        // 1. 使用最原始的columns作为数据源，确保辅助列完全不受影响
-        const originalColumns = cloneDeep(this.columns);
-        // 2. 处理字段映射（如果提供了fields参数）
-        let processedInjectColumns = injectColumns;
-        // 3. 分离辅助列和非辅助列（使用原始数据）
-        const nonAuxiliaryColumns = originalColumns.filter((col) => !col.auxiliaryColumn);
-        // 4. 按照injectColumns的顺序重新排列非辅助列
-        const reorderedNonAuxiliaryColumns = [];
-        const remainingNonAuxiliaryColumns = [...nonAuxiliaryColumns]; // 复制一份用于查找和移除
-        processedInjectColumns.forEach((injectCol) => {
-            // 查找非辅助列中对应的下标
-            const existingColIndex = remainingNonAuxiliaryColumns.findIndex((col) => col.prop === injectCol.prop);
-            if (existingColIndex !== -1) {
-                // 如果找到相同列，用injectColumns中的属性覆盖原始columns中的属性
-                const existingCol = remainingNonAuxiliaryColumns[existingColIndex];
-                const updatedCol = { ...existingCol, ...injectCol };
-                reorderedNonAuxiliaryColumns.push(updatedCol);
-                // 从剩余数组中移除，避免重复
-                remainingNonAuxiliaryColumns.splice(existingColIndex, 1);
-            }
-            else {
-                // 如果没找到对应的列，直接添加injectColumns中的列
-                reorderedNonAuxiliaryColumns.push(injectCol);
-            }
-        });
-        // 5. 处理剩余的原始columns中的非辅助列（在injectColumns中未出现的列）
-        // 这些列应该被隐藏（设置hideInTable为true）
-        remainingNonAuxiliaryColumns.forEach((remainingCol) => {
-            const hiddenCol = { ...remainingCol, hideInTable: true };
-            reorderedNonAuxiliaryColumns.push(hiddenCol);
-        });
-        // 6. 按照原始columns的顺序重新组合：保持辅助列的原始位置和属性
-        const finalColumns = [];
-        let nonAuxiliaryIndex = 0;
-        let auxiliaryIndex = 0;
-        originalColumns.forEach((originalCol) => {
-            if (originalCol.auxiliaryColumn) {
-                // 如果是辅助列，使用原始列数据，完全不进行任何修改
-                finalColumns.push(originalCol);
-                auxiliaryIndex++;
-            }
-            else {
-                // 如果是非辅助列，使用重新排序后的列，但保留原始列的所有属性
-                const reorderedCol = reorderedNonAuxiliaryColumns[nonAuxiliaryIndex];
-                if (reorderedCol) {
-                    // 合并原始列和重新排序后的列，确保保留所有原始属性
-                    const mergedCol = { ...originalCol, ...reorderedCol };
-                    finalColumns.push(mergedCol);
-                }
-                else {
-                    // 如果重新排序后的列不存在，使用原始列
-                    finalColumns.push(originalCol);
-                }
-                nonAuxiliaryIndex++;
-            }
+        // 远程列直接作为来源，过滤掉本地不存在的列，并从本地列补充渲染配置
+        const remoteColumns = injectColumns
+            .filter((injectCol) => this.columns.some((col) => col.prop === injectCol.prop))
+            .map((injectCol) => {
+            const localCol = this.columns.find((col) => col.prop === injectCol.prop);
+            return { ...localCol, ...injectCol };
         });
-        this.formateInnerColumns(finalColumns);
+        // 辅助列取自本地，保持在原始位置（首部 / 尾部）
+        const firstNonAuxIndex = this.columns.findIndex((c) => !c.auxiliaryColumn);
+        const lastNonAuxIndex = this.columns.length -
+            1 -
+            [...this.columns].reverse().findIndex((c) => !c.auxiliaryColumn);
+        const headAuxiliary = this.columns.filter((col, i) => col.auxiliaryColumn && i < firstNonAuxIndex);
+        const tailAuxiliary = this.columns.filter((col, i) => col.auxiliaryColumn && i > lastNonAuxIndex);
+        this.formateInnerColumns([...headAuxiliary, ...remoteColumns, ...tailAuxiliary]);
     }
     // 通过 Proxy 监听 _searchParams 的属性变更
     createSearchParamsProxy(target) {