fantasy-ngzorro 2.2.37 → 2.2.38

package/bundles/fantasy-ngzorro.umd.js

@@ -1502,7 +1502,8 @@
         return getTableViewportWidth(nzTable, hostClass);
     }
     /**
-     * 无数据或列宽未超出容器时不启用横向 scroll（fluid：表宽 100%，勾选/序号列由 CSS 锁宽）
+     * 无数据或列宽未超出容器时不启用横向 scroll（表宽 100%、table-layout: auto）。
+     * auto 布局下单元格 max-width 不生效，固定宽列会被均摊撑开；需要锁宽的场景见 hd-table 的横向布局。
      * @param {?} nzTable
      * @param {?} hasData
      * @param {?=} colWidth
@@ -10951,6 +10952,67 @@
      * @fileoverview added by tsickle
      * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
      */
+    /**
+     * 勾选列宽（px），与模板 nzWidth、less 兜底保持一致
+     * @type {?}
+     */
+    var SELECT_COL_WIDTH = 40;
+    /**
+     * 横向布局计算结果
+     * @record
+     */
+    function HdTableHorizontalLayout() { }
+    if (false) {
+        /**
+         * 传给 nzScroll.x；只有列宽总和 <= 0 时为 null
+         * @type {?}
+         */
+        HdTableHorizontalLayout.prototype.scrollX;
+        /**
+         * 补到最后一列业务列上的宽度，列多时为 0
+         * @type {?}
+         */
+        HdTableHorizontalLayout.prototype.fluidExtra;
+        /**
+         * 实际渲染总宽 = 声明总宽 + fluidExtra
+         * @type {?}
+         */
+        HdTableHorizontalLayout.prototype.displayTotal;
+        /**
+         * 列少、靠补宽吃满容器，不需要真正横滚
+         * @type {?}
+         */
+        HdTableHorizontalLayout.prototype.isFluid;
+    }
+    /**
+     * 列多（或量不到容器宽）：scroll.x = 声明总宽，正常横滚
+     * @param {?} declaredWidth
+     * @return {?}
+     */
+    function fixedLayout(declaredWidth) {
+        return {
+            scrollX: Math.ceil(declaredWidth) + "px",
+            fluidExtra: 0,
+            displayTotal: declaredWidth,
+            isFluid: false,
+        };
+    }
+    /**
+     * 列少：scroll.x = 容器宽，差额补到最后一列业务列
+     * @param {?} containerWidth
+     * @param {?} declaredWidth
+     * @return {?}
+     */
+    function fluidLayout(containerWidth, declaredWidth) {
+        /** @type {?} */
+        var fluidExtra = Math.max(0, containerWidth - declaredWidth);
+        return {
+            scrollX: containerWidth + "px",
+            fluidExtra: fluidExtra,
+            displayTotal: declaredWidth + fluidExtra,
+            isFluid: true,
+        };
+    }
     var HdTableComponent = /** @class */ (function () {
         function HdTableComponent(hostEl, cdr, commonSessionService) {
             var _this = this;
@@ -11036,21 +11098,19 @@
              */
             this.virtualScrollActive = null;
             /**
-             * 列宽合计（含勾选/序号 + fluid 补宽），footer 表宽与横向 scroll 共用
+             * 实际渲染列宽合计（含勾选/序号 + 补宽），合计 footer 表宽用
              */
             this.tableColWidthTotal = 0;
             /**
-             * fluid：声明列总宽 < 容器时，把差额补到最后一列业务列（不改缓存宽），
-             * 并设 scroll.x = 容器宽，避免表宽 100% 均摊撑开勾选列；拖拽改宽仍写 col.width。
+             * 补到 fluidExtraTargetCol 上的宽度；只影响展示，不写回 col.width（列宽缓存、拖拽仍用声明宽）
              */
             this.fluidExtraWidth = 0;
             /**
-             * 列总宽未超出容器（fluid 补宽吃满）：不需要真正横滚，
-             * 用于关掉 ng-zorro fixed-header 带来的常驻 X 轴滚动条。
+             * 列少、靠补宽吃满容器：模板据此加 hd-table--fluid-x，隐藏 fixed-header 常驻的横滚槽
              */
             this.fluidHorizontal = false;
             /**
-             * fluid 补宽目标列缓存，避免模板每格 CD 时反复扫 tableCols
+             * 接收补宽的列，缓存起来避免模板每个单元格都扫一遍 tableCols
              */
             this.fluidExtraTargetCol = null;
             /**
@@ -11274,10 +11334,8 @@
                     changes["tableData"]["currentValue"]["pageNumber"] !==
                         changes["tableData"]["previousValue"]["pageNumber"]) {
                     this.pendingResetScrollTop = true;
-                    // pageSize/pageNumber 变化也要重算 scroll / fluid。
-                    // 业务常把 Page.pageSize 写成 content.length（如收款编辑 toPage），
-                    // virtualScroll=false 时若这里跳过，空表初始化后的 fluid 不会补上，勾选列被撑开。
-                    // applyTableScrollMode(false) 在模式未变时只 dealScroll，不会强制重建清排序态。
+                    // 业务可能把 Page.pageSize 写成 content.length，换数据时就会走到这里，
+                    // 必须重算横向布局。滚动模式不变时不会重建，排序态不会被清掉。
                     this.applyTableScrollMode(false);
                     // 翻页/改 pageSize：主动多次复位，覆盖 CDK 异步渲染时序
                     this.scheduleResetTableBodyScrollTop();
@@ -11289,9 +11347,7 @@
             }
             if (changes["tableData"]) {
                 this.pendingResetScrollTop = true;
-                // 不论是否虚拟滚动都要重算 scroll / fluid。
-                // 收款/付款编辑等页 [virtualScroll]=false + 异步灌数据：原先跳过会导致
-                // 空表初始化后不再补宽，勾选列被均摊撑开。
+                // 不论是否虚拟滚动，数据变化后都要重算横向布局
                 this.applyTableScrollMode(false);
                 // 数据更新后复位纵向滚动（含虚拟滚动场景）
                 this.scheduleResetTableBodyScrollTop();
@@ -11532,13 +11588,13 @@
             return col.fixed === "left" ? (col.fixedWidth || 0) + "px" : null;
         };
         Object.defineProperty(HdTableComponent.prototype, "lineNumberLeft", {
-            /** 开启合计时序号列的 left（勾选列占 40px） */
+            /** 开启合计时序号列的 left（跟在勾选列后面） */
             get: /**
-             * 开启合计时序号列的 left（勾选列占 40px）
+             * 开启合计时序号列的 left（跟在勾选列后面）
              * @return {?}
              */
             function () {
-                return this.showSelected ? "40px" : "0px";
+                return (this.showSelected ? SELECT_COL_WIDTH : 0) + "px";
             },
             enumerable: true,
             configurable: true
@@ -11569,64 +11625,141 @@
             enumerable: true,
             configurable: true
         });
-        /** 展示用列宽：fluid 时最后一列业务列 = 声明宽 + fluidExtraWidth */
         /**
-         * 展示用列宽：fluid 时最后一列业务列 = 声明宽 + fluidExtraWidth
+         * @private
+         * @param {?} col
+         * @return {?}
+         */
+        HdTableComponent.prototype.isColVisible = /**
+         * @private
+         * @param {?} col
+         * @return {?}
+         */
+        function (col) {
+            return !!col && col.isShow !== false;
+        };
+        /** 业务列声明宽：未配置时按 fixColWidth */
+        /**
+         * 业务列声明宽：未配置时按 fixColWidth
+         * @private
+         * @param {?} col
+         * @return {?}
+         */
+        HdTableComponent.prototype.getColDeclaredWidth = /**
+         * 业务列声明宽：未配置时按 fixColWidth
+         * @private
+         * @param {?} col
+         * @return {?}
+         */
+        function (col) {
+            return col && col.width > 0 ? col.width : ColWidth.fixColWidth;
+        };
+        /** 声明列宽合计：勾选列 + 序号列 + 可见业务列，不含补宽 */
+        /**
+         * 声明列宽合计：勾选列 + 序号列 + 可见业务列，不含补宽
+         * @private
+         * @return {?}
+         */
+        HdTableComponent.prototype.getDeclaredColWidthTotal = /**
+         * 声明列宽合计：勾选列 + 序号列 + 可见业务列，不含补宽
+         * @private
+         * @return {?}
+         */
+        function () {
+            var _this = this;
+            /** @type {?} */
+            var total = 0;
+            if (this.showSelected) {
+                total += SELECT_COL_WIDTH;
+            }
+            if (this.showTableTotal) {
+                total += this.lineNumberColWidth;
+            }
+            (this.tableCols || []).forEach((/**
+             * @param {?} col
+             * @return {?}
+             */
+            function (col) {
+                if (_this.isColVisible(col)) {
+                    total += _this.getColDeclaredWidth(col);
+                }
+            }));
+            return total;
+        };
+        /** 模板里 th / td / 合计 col 用的列宽：补宽目标列 = 声明宽 + fluidExtraWidth */
+        /**
+         * 模板里 th / td / 合计 col 用的列宽：补宽目标列 = 声明宽 + fluidExtraWidth
          * @param {?} col
          * @return {?}
          */
         HdTableComponent.prototype.getColDisplayWidth = /**
-         * 展示用列宽：fluid 时最后一列业务列 = 声明宽 + fluidExtraWidth
+         * 模板里 th / td / 合计 col 用的列宽：补宽目标列 = 声明宽 + fluidExtraWidth
          * @param {?} col
          * @return {?}
          */
         function (col) {
             /** @type {?} */
-            var base = col && col.width != null && col.width > 0
-                ? col.width
-                : ColWidth.fixColWidth;
-            if (this.fluidExtraWidth <= 0 ||
-                !col ||
-                !this.fluidExtraTargetCol ||
-                col !== this.fluidExtraTargetCol) {
-                return base;
+            var declared = this.getColDeclaredWidth(col);
+            if (this.fluidExtraWidth > 0 && col && col === this.fluidExtraTargetCol) {
+                return declared + this.fluidExtraWidth;
             }
-            return base + this.fluidExtraWidth;
+            return declared;
         };
-        /** 按当前 layout 刷新 fluid 补宽目标列（仅 dealScroll / sync 时调用） */
         /**
-         * 按当前 layout 刷新 fluid 补宽目标列（仅 dealScroll / sync 时调用）
+         * 选出接收补宽的列：优先最后一列「非右侧固定」的可见列，
+         * 避免把操作列等右固定列拉宽；全是右固定列时退回最后一列可见列。
+         */
+        /**
+         * 选出接收补宽的列：优先最后一列「非右侧固定」的可见列，
+         * 避免把操作列等右固定列拉宽；全是右固定列时退回最后一列可见列。
          * @private
          * @return {?}
          */
-        HdTableComponent.prototype.refreshFluidExtraTargetCol = /**
-         * 按当前 layout 刷新 fluid 补宽目标列（仅 dealScroll / sync 时调用）
+        HdTableComponent.prototype.findFluidExtraTargetCol = /**
+         * 选出接收补宽的列：优先最后一列「非右侧固定」的可见列，
+         * 避免把操作列等右固定列拉宽；全是右固定列时退回最后一列可见列。
          * @private
          * @return {?}
          */
         function () {
-            this.fluidExtraTargetCol = null;
-            if (this.fluidExtraWidth <= 0 ||
-                !this.tableCols ||
-                !this.tableCols.length) {
-                return;
-            }
-            for (var i = this.tableCols.length - 1; i >= 0; i--) {
+            /** @type {?} */
+            var cols = this.tableCols || [];
+            /** @type {?} */
+            var lastVisible = null;
+            for (var i = cols.length - 1; i >= 0; i--) {
                 /** @type {?} */
-                var c = this.tableCols[i];
-                if (c && c.isShow && c.fixed !== "right") {
-                    this.fluidExtraTargetCol = c;
-                    return;
+                var col = cols[i];
+                if (!this.isColVisible(col)) {
+                    continue;
                 }
-            }
-            for (var i = this.tableCols.length - 1; i >= 0; i--) {
-                /** @type {?} */
-                var c = this.tableCols[i];
-                if (c && c.isShow) {
-                    this.fluidExtraTargetCol = c;
-                    return;
+                if (col.fixed !== "right") {
+                    return col;
+                }
+                if (!lastVisible) {
+                    lastVisible = col;
                 }
             }
+            return lastVisible;
+        };
+        /** 把横向布局结果写回组件状态（dealScroll / syncHorizontalScroll 共用） */
+        /**
+         * 把横向布局结果写回组件状态（dealScroll / syncHorizontalScroll 共用）
+         * @private
+         * @param {?} layout
+         * @return {?}
+         */
+        HdTableComponent.prototype.applyHorizontalLayout = /**
+         * 把横向布局结果写回组件状态（dealScroll / syncHorizontalScroll 共用）
+         * @private
+         * @param {?} layout
+         * @return {?}
+         */
+        function (layout) {
+            this.fluidExtraWidth = layout.fluidExtra;
+            this.fluidHorizontal = layout.isFluid;
+            this.fluidExtraTargetCol =
+                layout.fluidExtra > 0 ? this.findFluidExtraTargetCol() : null;
+            this.tableColWidthTotal = layout.displayTotal;
         };
         Object.defineProperty(HdTableComponent.prototype, "totalFooterTableWidth", {
             /** fluid → 100%；固定 → scroll.x（与表体同一套横向宽度） */
@@ -11754,7 +11887,6 @@
          * @return {?}
          */
         function (forceRemount) {
-            var _this = this;
             if (forceRemount === void 0) { forceRemount = false; }
             /** @type {?} */
             var useVirtual = this.useVirtualScroll;
@@ -11767,23 +11899,7 @@
                 // ng-zorro 只在 AfterViewInit 绑一次 header/body 的 scroll 同步；
                 // 若先以 y=null 创建再改成有 y，表头监听会丢，表现为列头不跟着横滚。
                 this.presetScrollBeforeRemount(useVirtual);
-                this.showTable = false;
-                this.cdr.markForCheck();
-                setTimeout((/**
-                 * @return {?}
-                 */
-                function () {
-                    _this.showTable = true;
-                    _this.cdr.markForCheck();
-                    setTimeout((/**
-                     * @return {?}
-                     */
-                    function () {
-                        _this.dealScroll();
-                        _this.cdr.markForCheck();
-                        _this.afterTableRender(useVirtual);
-                    }));
-                }));
+                this.remountTable(useVirtual);
                 return;
             }
             /** @type {?} */
@@ -11795,32 +11911,48 @@
             var nextHasX = !!(this.scroll && this.scroll.x);
             /** @type {?} */
             var nextHasY = !!(this.scroll && this.scroll.y);
-            // 运行中 x/y 从有变无/从无变有时，也必须重建：
-            // - y：ng-zorro 只在 AfterViewInit 绑一次 header/body 同步
-            // - x：空表 scroll.x=null（table-layout:auto）→ 有数据后设 scroll.x（fixed），
-            //   不重建时勾选列仍按 auto 均摊撑开（收款编辑等异步灌数页）
+            // scroll.x / scroll.y 从无到有（或反过来）时必须重建，原地改值不生效：
+            // - y：ng-zorro 8 只在 AfterViewInit 绑一次表头/表体滚动同步，且决定表头是否拆成独立 table
+            // - x：决定是否带 ant-table-fixed（table-layout: fixed），勾选列锁宽依赖它
             if (prevHasY !== nextHasY || prevHasX !== nextHasX) {
-                this.showTable = false;
-                this.cdr.markForCheck();
+                this.remountTable(useVirtual);
+                return;
+            }
+            this.cdr.markForCheck();
+            this.afterTableRender(useVirtual);
+        };
+        /** 销毁并重建 nz-table：等 DOM 出来后再按真实容器宽重算一次横向布局 */
+        /**
+         * 销毁并重建 nz-table：等 DOM 出来后再按真实容器宽重算一次横向布局
+         * @private
+         * @param {?} useVirtual
+         * @return {?}
+         */
+        HdTableComponent.prototype.remountTable = /**
+         * 销毁并重建 nz-table：等 DOM 出来后再按真实容器宽重算一次横向布局
+         * @private
+         * @param {?} useVirtual
+         * @return {?}
+         */
+        function (useVirtual) {
+            var _this = this;
+            this.showTable = false;
+            this.cdr.markForCheck();
+            setTimeout((/**
+             * @return {?}
+             */
+            function () {
+                _this.showTable = true;
+                _this.cdr.markForCheck();
                 setTimeout((/**
                  * @return {?}
                  */
                 function () {
-                    _this.showTable = true;
+                    _this.dealScroll();
                     _this.cdr.markForCheck();
-                    setTimeout((/**
-                     * @return {?}
-                     */
-                    function () {
-                        _this.dealScroll();
-                        _this.cdr.markForCheck();
-                        _this.afterTableRender(useVirtual);
-                    }));
+                    _this.afterTableRender(useVirtual);
                 }));
-                return;
-            }
-            this.cdr.markForCheck();
-            this.afterTableRender(useVirtual);
+            }));
         };
         /** 重建前预设 scroll，保证 AfterViewInit 时 header/body 结构已正确 */
         /**
@@ -12685,48 +12817,62 @@
         function (maxOffset) {
             return "calc(100vh - " + maxOffset + "px)";
         };
-        /**
-         * @private
-         * @return {?}
-         */
-        HdTableComponent.prototype.hasTableData = /**
-         * @private
-         * @return {?}
-         */
-        function () {
-            return !!(this.tableData &&
-                this.tableData.content &&
-                this.tableData.content.length);
-        };
-        /**
-         * 按声明列总宽 + 容器宽，计算 scroll.x 与 fluid 补宽。
-         * 列少：scroll.x = 内容区宽（clientWidth），差额加到最后业务列（勾选保持 40）；
-         * 列多：scroll.x = 声明总宽。
-         * 比较是否超宽用 offsetWidth（含 Y 槽），避免「仅因纵滚条」误开横滚；
-         * 补宽目标用 clientWidth，且 scroll.x 用 floor，避免表宽多 1px 逼出 X 轴滚动条。
-         */
-        /**
-         * 按声明列总宽 + 容器宽，计算 scroll.x 与 fluid 补宽。
-         * 列少：scroll.x = 内容区宽（clientWidth），差额加到最后业务列（勾选保持 40）；
-         * 列多：scroll.x = 声明总宽。
-         * 比较是否超宽用 offsetWidth（含 Y 槽），避免「仅因纵滚条」误开横滚；
-         * 补宽目标用 clientWidth，且 scroll.x 用 floor，避免表宽多 1px 逼出 X 轴滚动条。
+        /*
+         * 横向布局（勾选列锁 40px 的关键）
+         *
+         * 勾选列只有在 table-layout: fixed 下才锁得住：ng-zorro 8 仅在 nzScroll.x 有值时
+         * 给 table 加 ant-table-fixed；auto 布局下 table 宽 100%、每列都有 nzWidth，
+         * 剩余空间会按比例摊到所有列（含勾选列），单元格上的 max-width 也不生效。
+         * 所以只要有列（无论有没有数据）就一定设置 scroll.x：
+         * - 列少：scroll.x = 容器宽，差额补到最后一列业务列（fluid，不出真横滚）
+         * - 列多：scroll.x = 声明总宽，正常横滚
+         * less 里勾选列的 40px 只是 fixed 布局下的兜底。
+         */
+        /**
+         * 按声明列宽合计 + 容器宽算出横向布局。
+         * 判断「是否超宽」用 offsetWidth（含竖滚条槽），避免只因竖滚条就误开横滚；
+         * 补宽目标用 clientWidth 并向下取整，避免表宽多 1px 逼出横滚条。
+         */
+        /*
+           * 横向布局（勾选列锁 40px 的关键）
+           *
+           * 勾选列只有在 table-layout: fixed 下才锁得住：ng-zorro 8 仅在 nzScroll.x 有值时
+           * 给 table 加 ant-table-fixed；auto 布局下 table 宽 100%、每列都有 nzWidth，
+           * 剩余空间会按比例摊到所有列（含勾选列），单元格上的 max-width 也不生效。
+           * 所以只要有列（无论有没有数据）就一定设置 scroll.x：
+           * - 列少：scroll.x = 容器宽，差额补到最后一列业务列（fluid，不出真横滚）
+           * - 列多：scroll.x = 声明总宽，正常横滚
+           * less 里勾选列的 40px 只是 fixed 布局下的兜底。
+           */
+        /**
+         * 按声明列宽合计 + 容器宽算出横向布局。
+         * 判断「是否超宽」用 offsetWidth（含竖滚条槽），避免只因竖滚条就误开横滚；
+         * 补宽目标用 clientWidth 并向下取整，避免表宽多 1px 逼出横滚条。
          * @private
          * @param {?} declaredColWidth
          * @return {?}
          */
-        HdTableComponent.prototype.resolveHorizontalLayout = /**
-         * 按声明列总宽 + 容器宽，计算 scroll.x 与 fluid 补宽。
-         * 列少：scroll.x = 内容区宽（clientWidth），差额加到最后业务列（勾选保持 40）；
-         * 列多：scroll.x = 声明总宽。
-         * 比较是否超宽用 offsetWidth（含 Y 槽），避免「仅因纵滚条」误开横滚；
-         * 补宽目标用 clientWidth，且 scroll.x 用 floor，避免表宽多 1px 逼出 X 轴滚动条。
+        HdTableComponent.prototype.resolveHorizontalLayout = /*
+           * 横向布局（勾选列锁 40px 的关键）
+           *
+           * 勾选列只有在 table-layout: fixed 下才锁得住：ng-zorro 8 仅在 nzScroll.x 有值时
+           * 给 table 加 ant-table-fixed；auto 布局下 table 宽 100%、每列都有 nzWidth，
+           * 剩余空间会按比例摊到所有列（含勾选列），单元格上的 max-width 也不生效。
+           * 所以只要有列（无论有没有数据）就一定设置 scroll.x：
+           * - 列少：scroll.x = 容器宽，差额补到最后一列业务列（fluid，不出真横滚）
+           * - 列多：scroll.x = 声明总宽，正常横滚
+           * less 里勾选列的 40px 只是 fixed 布局下的兜底。
+           */
+        /**
+         * 按声明列宽合计 + 容器宽算出横向布局。
+         * 判断「是否超宽」用 offsetWidth（含竖滚条槽），避免只因竖滚条就误开横滚；
+         * 补宽目标用 clientWidth 并向下取整，避免表宽多 1px 逼出横滚条。
          * @private
          * @param {?} declaredColWidth
          * @return {?}
          */
         function (declaredColWidth) {
-            if (!this.hasTableData() || declaredColWidth <= 0) {
+            if (declaredColWidth <= 0) {
                 return {
                     scrollX: null,
                     fluidExtra: 0,
@@ -12735,115 +12881,63 @@
                 };
             }
             /** @type {?} */
-            var viewportCompare = this.nzTableComponent
+            var compareWidth = this.nzTableComponent
                 ? getTableScrollXViewportWidth(this.nzTableComponent)
                 : 0;
-            // 表体尚未量到宽时（异步灌数 / spin / 刚 remount），用宿主宽兜底
-            if (viewportCompare <= 0 && this.hostEl && this.hostEl.nativeElement) {
-                /** @type {?} */
-                var hostW = ((/** @type {?} */ (this.hostEl.nativeElement))).offsetWidth;
-                if (hostW > 0) {
-                    viewportCompare = hostW;
-                }
+            // 表体还没渲染出来（刚重建 / 在 spin 里）时用宿主宽兜底
+            if (compareWidth <= 0 && this.hostEl && this.hostEl.nativeElement) {
+                compareWidth = ((/** @type {?} */ (this.hostEl.nativeElement))).offsetWidth;
             }
-            if (viewportCompare > 0) {
-                if (declaredColWidth > viewportCompare + 1) {
-                    return {
-                        scrollX: Math.ceil(declaredColWidth) + "px",
-                        fluidExtra: 0,
-                        displayTotal: declaredColWidth,
-                        isFluid: false,
-                    };
-                }
-                /** @type {?} */
-                var fillWidth = this.nzTableComponent
-                    ? getTableViewportWidth(this.nzTableComponent)
-                    : 0;
-                /** @type {?} */
-                var target = Math.floor(fillWidth > 0 ? fillWidth : viewportCompare);
-                /** @type {?} */
-                var fluidExtra = Math.max(0, target - declaredColWidth);
-                return {
-                    scrollX: target + "px",
-                    fluidExtra: fluidExtra,
-                    displayTotal: declaredColWidth + fluidExtra,
-                    isFluid: true,
-                };
+            // 仍量不到（如宿主在 display:none 里）：先按声明宽走 fixed，等 ResizeObserver 触发再转 fluid
+            if (compareWidth <= 0) {
+                return fixedLayout(declaredColWidth);
             }
-            // 视口仍测不到：至少用声明宽设 scroll.x，强制 fixed 布局锁勾选列，
-            // 避免落回 table-layout:auto 被均摊撑开；后续 sync/remount 再转 fluid。
-            return {
-                scrollX: Math.ceil(declaredColWidth) + "px",
-                fluidExtra: 0,
-                displayTotal: declaredColWidth,
-                isFluid: false,
-            };
+            // 1px 容差，避免亚像素误判
+            if (declaredColWidth > compareWidth + 1) {
+                return fixedLayout(declaredColWidth);
+            }
+            /** @type {?} */
+            var fillWidth = this.nzTableComponent
+                ? getTableViewportWidth(this.nzTableComponent)
+                : 0;
+            /** @type {?} */
+            var containerWidth = Math.floor(fillWidth > 0 ? fillWidth : compareWidth);
+            return fluidLayout(containerWidth, declaredColWidth);
         };
-        /** 表格渲染后按实际容器宽度校正横向 scroll / fluid 补宽 */
+        /** 表格渲染后按真实容器宽校正横向布局；只改 x，y 保持不变 */
         /**
-         * 表格渲染后按实际容器宽度校正横向 scroll / fluid 补宽
+         * 表格渲染后按真实容器宽校正横向布局；只改 x，y 保持不变
          * @private
          * @return {?}
          */
         HdTableComponent.prototype.syncHorizontalScroll = /**
-         * 表格渲染后按实际容器宽度校正横向 scroll / fluid 补宽
+         * 表格渲染后按真实容器宽校正横向布局；只改 x，y 保持不变
          * @private
          * @return {?}
          */
         function () {
             var _this = this;
             /** @type {?} */
-            var declared = 0;
-            if (this.showSelected) {
-                declared += 40;
-            }
-            if (this.showTableTotal) {
-                declared += this.lineNumberColWidth;
-            }
-            if (this.tableCols) {
-                this.tableCols.forEach((/**
-                 * @param {?} item
-                 * @return {?}
-                 */
-                function (item) {
-                    if (item && item.isShow !== false) {
-                        declared += item.width > 0 ? item.width : ColWidth.fixColWidth;
-                    }
-                }));
-            }
-            /** @type {?} */
             var prevHasX = !!(this.scroll && this.scroll.x);
             /** @type {?} */
-            var layout = this.resolveHorizontalLayout(declared);
-            /** @type {?} */
-            var currentY = this.scroll ? this.scroll.y : null;
-            /** @type {?} */
-            var nextHasX = !!layout.scrollX;
+            var layout = this.resolveHorizontalLayout(this.getDeclaredColWidthTotal());
             /** @type {?} */
-            var sameX = this.scroll && this.scroll.x === layout.scrollX;
-            /** @type {?} */
-            var sameExtra = this.fluidExtraWidth === layout.fluidExtra;
-            /** @type {?} */
-            var sameFluid = this.fluidHorizontal === layout.isFluid;
-            if (sameX &&
-                sameExtra &&
-                sameFluid &&
-                this.scroll &&
-                this.scroll.y === currentY) {
+            var unchanged = this.scroll &&
+                this.scroll.x === layout.scrollX &&
+                this.fluidExtraWidth === layout.fluidExtra &&
+                this.fluidHorizontal === layout.isFluid;
+            if (unchanged) {
                 setTimeout((/**
                  * @return {?}
                  */
                 function () { return _this.syncTotalFooterWithBody(); }));
                 return;
             }
-            this.fluidExtraWidth = layout.fluidExtra;
-            this.fluidHorizontal = layout.isFluid;
-            this.refreshFluidExtraTargetCol();
-            this.tableColWidthTotal = layout.displayTotal;
-            this.scroll = { x: layout.scrollX, y: currentY };
+            this.applyHorizontalLayout(layout);
+            this.scroll = { x: layout.scrollX, y: this.scroll ? this.scroll.y : null };
             this.cdr.markForCheck();
-            // sync 阶段若补上了 scroll.x，需重建才能切到 fixed 布局
-            if (prevHasX !== nextHasX) {
+            // x 从无到有（或反过来）要重建才能切换 table-layout
+            if (prevHasX !== !!layout.scrollX) {
                 this.applyTableScrollMode(true);
                 return;
             }
@@ -13163,13 +13257,15 @@
          * @return {?}
          */
         function () {
+            var _this = this;
+            // 左侧固定列：从左往右累计偏移（勾选列、序号列在最前面）
             /** @type {?} */
-            var colWidth = 0;
+            var leftOffset = 0;
             if (this.showSelected) {
-                colWidth += 40;
+                leftOffset += SELECT_COL_WIDTH;
             }
             if (this.showTableTotal) {
-                colWidth += this.lineNumberColWidth; // 序号列（固定宽，不随位数变化）
+                leftOffset += this.lineNumberColWidth;
             }
             this.tableCols.forEach((/**
              * @param {?} item
@@ -13179,9 +13275,9 @@
                 if (!item.width) {
                     item.width = ColWidth.fixColWidth;
                 }
-                if (item.isShow !== false) {
-                    item.fixedWidth = colWidth;
-                    colWidth += item.width;
+                if (_this.isColVisible(item)) {
+                    item.fixedWidth = leftOffset;
+                    leftOffset += item.width;
                 }
             }));
             // 右侧固定列：从右往左累计偏移，避免多列都 right:0 互相遮挡
@@ -13190,7 +13286,7 @@
             for (var i = this.tableCols.length - 1; i >= 0; i--) {
                 /** @type {?} */
                 var item = this.tableCols[i];
-                if (item.isShow === false) {
+                if (!this.isColVisible(item)) {
                     continue;
                 }
                 if (item.fixed === "right") {
@@ -13202,11 +13298,8 @@
                 }
             }
             /** @type {?} */
-            var layout = this.resolveHorizontalLayout(colWidth);
-            this.fluidExtraWidth = layout.fluidExtra;
-            this.fluidHorizontal = layout.isFluid;
-            this.refreshFluidExtraTargetCol();
-            this.tableColWidthTotal = layout.displayTotal;
+            var layout = this.resolveHorizontalLayout(this.getDeclaredColWidthTotal());
+            this.applyHorizontalLayout(layout);
             /** @type {?} */
             var maxOffset = this.getScrollYMaxOffset();
             /** @type {?} */
@@ -14681,24 +14774,22 @@
          */
         HdTableComponent.prototype.virtualScrollActive;
         /**
-         * 列宽合计（含勾选/序号 + fluid 补宽），footer 表宽与横向 scroll 共用
+         * 实际渲染列宽合计（含勾选/序号 + 补宽），合计 footer 表宽用
          * @type {?}
          */
         HdTableComponent.prototype.tableColWidthTotal;
         /**
-         * fluid：声明列总宽 < 容器时，把差额补到最后一列业务列（不改缓存宽），
-         * 并设 scroll.x = 容器宽，避免表宽 100% 均摊撑开勾选列；拖拽改宽仍写 col.width。
+         * 补到 fluidExtraTargetCol 上的宽度；只影响展示，不写回 col.width（列宽缓存、拖拽仍用声明宽）
          * @type {?}
          */
         HdTableComponent.prototype.fluidExtraWidth;
         /**
-         * 列总宽未超出容器（fluid 补宽吃满）：不需要真正横滚，
-         * 用于关掉 ng-zorro fixed-header 带来的常驻 X 轴滚动条。
+         * 列少、靠补宽吃满容器：模板据此加 hd-table--fluid-x，隐藏 fixed-header 常驻的横滚槽
          * @type {?}
          */
         HdTableComponent.prototype.fluidHorizontal;
         /**
-         * fluid 补宽目标列缓存，避免模板每格 CD 时反复扫 tableCols
+         * 接收补宽的列，缓存起来避免模板每个单元格都扫一遍 tableCols
          * @type {?}
          * @private
          */