fantasy-ngzorro 2.2.37 → 2.2.38

package/fesm2015/fantasy-ngzorro.js

@@ -1126,7 +1126,8 @@ function getTableScrollXViewportWidth(nzTable, hostClass = "hd-table-container")
     return getTableViewportWidth(nzTable, hostClass);
 }
 /**
- * 无数据或列宽未超出容器时不启用横向 scroll（fluid：表宽 100%，勾选/序号列由 CSS 锁宽）
+ * 无数据或列宽未超出容器时不启用横向 scroll（表宽 100%、table-layout: auto）。
+ * auto 布局下单元格 max-width 不生效，固定宽列会被均摊撑开；需要锁宽的场景见 hd-table 的横向布局。
  * @param {?} nzTable
  * @param {?} hasData
  * @param {?=} colWidth
@@ -9124,6 +9125,67 @@ if (false) {
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
+/**
+ * 勾选列宽（px），与模板 nzWidth、less 兜底保持一致
+ * @type {?}
+ */
+const 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 {?} */
+    const fluidExtra = Math.max(0, containerWidth - declaredWidth);
+    return {
+        scrollX: `${containerWidth}px`,
+        fluidExtra,
+        displayTotal: declaredWidth + fluidExtra,
+        isFluid: true,
+    };
+}
 class HdTableComponent {
     /**
      * @param {?} hostEl
@@ -9213,21 +9275,19 @@ class HdTableComponent {
          */
         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;
         /**
@@ -9434,10 +9494,8 @@ class HdTableComponent {
                 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();
@@ -9449,9 +9507,7 @@ class HdTableComponent {
         }
         if (changes["tableData"]) {
             this.pendingResetScrollTop = true;
-            // 不论是否虚拟滚动都要重算 scroll / fluid。
-            // 收款/付款编辑等页 [virtualScroll]=false + 异步灌数据：原先跳过会导致
-            // 空表初始化后不再补宽，勾选列被均摊撑开。
+            // 不论是否虚拟滚动，数据变化后都要重算横向布局
             this.applyTableScrollMode(false);
             // 数据更新后复位纵向滚动（含虚拟滚动场景）
             this.scheduleResetTableBodyScrollTop();
@@ -9631,11 +9687,11 @@ class HdTableComponent {
         return col.fixed === "left" ? `${col.fixedWidth || 0}px` : null;
     }
     /**
-     * 开启合计时序号列的 left（勾选列占 40px）
+     * 开启合计时序号列的 left（跟在勾选列后面）
      * @return {?}
      */
     get lineNumberLeft() {
-        return this.showSelected ? "40px" : "0px";
+        return (this.showSelected ? SELECT_COL_WIDTH : 0) + "px";
     }
     /**
      * @return {?}
@@ -9652,51 +9708,98 @@ class HdTableComponent {
         return !(this.scroll && this.scroll.x);
     }
     /**
-     * 展示用列宽：fluid 时最后一列业务列 = 声明宽 + fluidExtraWidth
+     * @private
+     * @param {?} col
+     * @return {?}
+     */
+    isColVisible(col) {
+        return !!col && col.isShow !== false;
+    }
+    /**
+     * 业务列声明宽：未配置时按 fixColWidth
+     * @private
+     * @param {?} col
+     * @return {?}
+     */
+    getColDeclaredWidth(col) {
+        return col && col.width > 0 ? col.width : ColWidth.fixColWidth;
+    }
+    /**
+     * 声明列宽合计：勾选列 + 序号列 + 可见业务列，不含补宽
+     * @private
+     * @return {?}
+     */
+    getDeclaredColWidthTotal() {
+        /** @type {?} */
+        let total = 0;
+        if (this.showSelected) {
+            total += SELECT_COL_WIDTH;
+        }
+        if (this.showTableTotal) {
+            total += this.lineNumberColWidth;
+        }
+        (this.tableCols || []).forEach((/**
+         * @param {?} col
+         * @return {?}
+         */
+        (col) => {
+            if (this.isColVisible(col)) {
+                total += this.getColDeclaredWidth(col);
+            }
+        }));
+        return total;
+    }
+    /**
+     * 模板里 th / td / 合计 col 用的列宽：补宽目标列 = 声明宽 + fluidExtraWidth
      * @param {?} col
      * @return {?}
      */
     getColDisplayWidth(col) {
         /** @type {?} */
-        const base = col && col.width != null && col.width > 0
-            ? col.width
-            : ColWidth.fixColWidth;
-        if (this.fluidExtraWidth <= 0 ||
-            !col ||
-            !this.fluidExtraTargetCol ||
-            col !== this.fluidExtraTargetCol) {
-            return base;
+        const 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 时调用）
+     * 选出接收补宽的列：优先最后一列「非右侧固定」的可见列，
+     * 避免把操作列等右固定列拉宽；全是右固定列时退回最后一列可见列。
      * @private
      * @return {?}
      */
-    refreshFluidExtraTargetCol() {
-        this.fluidExtraTargetCol = null;
-        if (this.fluidExtraWidth <= 0 ||
-            !this.tableCols ||
-            !this.tableCols.length) {
-            return;
-        }
-        for (let i = this.tableCols.length - 1; i >= 0; i--) {
+    findFluidExtraTargetCol() {
+        /** @type {?} */
+        const cols = this.tableCols || [];
+        /** @type {?} */
+        let lastVisible = null;
+        for (let i = cols.length - 1; i >= 0; i--) {
             /** @type {?} */
-            const c = this.tableCols[i];
-            if (c && c.isShow && c.fixed !== "right") {
-                this.fluidExtraTargetCol = c;
-                return;
+            const col = cols[i];
+            if (!this.isColVisible(col)) {
+                continue;
             }
-        }
-        for (let i = this.tableCols.length - 1; i >= 0; i--) {
-            /** @type {?} */
-            const 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 共用）
+     * @private
+     * @param {?} layout
+     * @return {?}
+     */
+    applyHorizontalLayout(layout) {
+        this.fluidExtraWidth = layout.fluidExtra;
+        this.fluidHorizontal = layout.isFluid;
+        this.fluidExtraTargetCol =
+            layout.fluidExtra > 0 ? this.findFluidExtraTargetCol() : null;
+        this.tableColWidthTotal = layout.displayTotal;
     }
     /**
      * fluid → 100%；固定 → scroll.x（与表体同一套横向宽度）
@@ -9811,23 +9914,7 @@ class HdTableComponent {
             // ng-zorro 只在 AfterViewInit 绑一次 header/body 的 scroll 同步；
             // 若先以 y=null 创建再改成有 y，表头监听会丢，表现为列头不跟着横滚。
             this.presetScrollBeforeRemount(useVirtual);
-            this.showTable = false;
-            this.cdr.markForCheck();
-            setTimeout((/**
-             * @return {?}
-             */
-            () => {
-                this.showTable = true;
-                this.cdr.markForCheck();
-                setTimeout((/**
-                 * @return {?}
-                 */
-                () => {
-                    this.dealScroll();
-                    this.cdr.markForCheck();
-                    this.afterTableRender(useVirtual);
-                }));
-            }));
+            this.remountTable(useVirtual);
             return;
         }
         /** @type {?} */
@@ -9839,32 +9926,40 @@ class HdTableComponent {
         const nextHasX = !!(this.scroll && this.scroll.x);
         /** @type {?} */
         const 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.remountTable(useVirtual);
+            return;
+        }
+        this.cdr.markForCheck();
+        this.afterTableRender(useVirtual);
+    }
+    /**
+     * 销毁并重建 nz-table：等 DOM 出来后再按真实容器宽重算一次横向布局
+     * @private
+     * @param {?} useVirtual
+     * @return {?}
+     */
+    remountTable(useVirtual) {
+        this.showTable = false;
+        this.cdr.markForCheck();
+        setTimeout((/**
+         * @return {?}
+         */
+        () => {
+            this.showTable = true;
             this.cdr.markForCheck();
             setTimeout((/**
              * @return {?}
              */
             () => {
-                this.showTable = true;
+                this.dealScroll();
                 this.cdr.markForCheck();
-                setTimeout((/**
-                 * @return {?}
-                 */
-                () => {
-                    this.dealScroll();
-                    this.cdr.markForCheck();
-                    this.afterTableRender(useVirtual);
-                }));
+                this.afterTableRender(useVirtual);
             }));
-            return;
-        }
-        this.cdr.markForCheck();
-        this.afterTableRender(useVirtual);
+        }));
     }
     /**
      * 重建前预设 scroll，保证 AfterViewInit 时 header/body 结构已正确
@@ -10582,27 +10677,27 @@ class HdTableComponent {
     getVirtualScrollY(maxOffset) {
         return `calc(100vh - ${maxOffset}px)`;
     }
-    /**
-     * @private
-     * @return {?}
-     */
-    hasTableData() {
-        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 轴滚动条。
+    /*
+       * 横向布局（勾选列锁 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 {?}
      */
     resolveHorizontalLayout(declaredColWidth) {
-        if (!this.hasTableData() || declaredColWidth <= 0) {
+        if (declaredColWidth <= 0) {
             return {
                 scrollX: null,
                 fluidExtra: 0,
@@ -10611,108 +10706,56 @@ class HdTableComponent {
             };
         }
         /** @type {?} */
-        let viewportCompare = this.nzTableComponent
+        let compareWidth = this.nzTableComponent
             ? getTableScrollXViewportWidth(this.nzTableComponent)
             : 0;
-        // 表体尚未量到宽时（异步灌数 / spin / 刚 remount），用宿主宽兜底
-        if (viewportCompare <= 0 && this.hostEl && this.hostEl.nativeElement) {
-            /** @type {?} */
-            const 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 {?} */
-            const fillWidth = this.nzTableComponent
-                ? getTableViewportWidth(this.nzTableComponent)
-                : 0;
-            /** @type {?} */
-            const target = Math.floor(fillWidth > 0 ? fillWidth : viewportCompare);
-            /** @type {?} */
-            const fluidExtra = Math.max(0, target - declaredColWidth);
-            return {
-                scrollX: `${target}px`,
-                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 {?} */
+        const fillWidth = this.nzTableComponent
+            ? getTableViewportWidth(this.nzTableComponent)
+            : 0;
+        /** @type {?} */
+        const containerWidth = Math.floor(fillWidth > 0 ? fillWidth : compareWidth);
+        return fluidLayout(containerWidth, declaredColWidth);
     }
     /**
-     * 表格渲染后按实际容器宽度校正横向 scroll / fluid 补宽
+     * 表格渲染后按真实容器宽校正横向布局；只改 x，y 保持不变
      * @private
      * @return {?}
      */
     syncHorizontalScroll() {
-        /** @type {?} */
-        let declared = 0;
-        if (this.showSelected) {
-            declared += 40;
-        }
-        if (this.showTableTotal) {
-            declared += this.lineNumberColWidth;
-        }
-        if (this.tableCols) {
-            this.tableCols.forEach((/**
-             * @param {?} item
-             * @return {?}
-             */
-            (item) => {
-                if (item && item.isShow !== false) {
-                    declared += item.width > 0 ? item.width : ColWidth.fixColWidth;
-                }
-            }));
-        }
         /** @type {?} */
         const prevHasX = !!(this.scroll && this.scroll.x);
         /** @type {?} */
-        const layout = this.resolveHorizontalLayout(declared);
+        const layout = this.resolveHorizontalLayout(this.getDeclaredColWidthTotal());
         /** @type {?} */
-        const currentY = this.scroll ? this.scroll.y : null;
-        /** @type {?} */
-        const nextHasX = !!layout.scrollX;
-        /** @type {?} */
-        const sameX = this.scroll && this.scroll.x === layout.scrollX;
-        /** @type {?} */
-        const sameExtra = this.fluidExtraWidth === layout.fluidExtra;
-        /** @type {?} */
-        const sameFluid = this.fluidHorizontal === layout.isFluid;
-        if (sameX &&
-            sameExtra &&
-            sameFluid &&
-            this.scroll &&
-            this.scroll.y === currentY) {
+        const unchanged = this.scroll &&
+            this.scroll.x === layout.scrollX &&
+            this.fluidExtraWidth === layout.fluidExtra &&
+            this.fluidHorizontal === layout.isFluid;
+        if (unchanged) {
             setTimeout((/**
              * @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;
         }
@@ -10956,13 +10999,14 @@ class HdTableComponent {
      * @return {?}
      */
     dealScroll() {
+        // 左侧固定列：从左往右累计偏移（勾选列、序号列在最前面）
         /** @type {?} */
-        let colWidth = 0;
+        let 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
@@ -10972,9 +11016,9 @@ class HdTableComponent {
             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 互相遮挡
@@ -10983,7 +11027,7 @@ class HdTableComponent {
         for (let i = this.tableCols.length - 1; i >= 0; i--) {
             /** @type {?} */
             const item = this.tableCols[i];
-            if (item.isShow === false) {
+            if (!this.isColVisible(item)) {
                 continue;
             }
             if (item.fixed === "right") {
@@ -10995,11 +11039,8 @@ class HdTableComponent {
             }
         }
         /** @type {?} */
-        const layout = this.resolveHorizontalLayout(colWidth);
-        this.fluidExtraWidth = layout.fluidExtra;
-        this.fluidHorizontal = layout.isFluid;
-        this.refreshFluidExtraTargetCol();
-        this.tableColWidthTotal = layout.displayTotal;
+        const layout = this.resolveHorizontalLayout(this.getDeclaredColWidthTotal());
+        this.applyHorizontalLayout(layout);
         /** @type {?} */
         const maxOffset = this.getScrollYMaxOffset();
         /** @type {?} */
@@ -12201,24 +12242,22 @@ if (false) {
      */
     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
      */