fantasy-ngzorro 2.1.37 → 2.1.39

package/bundles/fantasy-ngzorro.umd.js

@@ -7559,6 +7559,10 @@
              * 可见列总宽，用于判断是否需要横向滚动
              */
             this.tableColWidthTotal = 0;
+            /**
+             * 数据更新后待复位纵向滚动位置
+             */
+            this.pendingResetScrollTop = false;
             /**
              * 当前排序，表格重建后用于恢复表头排序态
              */
@@ -7707,19 +7711,27 @@
                     changes["tableData"]["previousValue"]["pageSize"] ||
                     changes["tableData"]["currentValue"]["pageNumber"] !==
                         changes["tableData"]["previousValue"]["pageNumber"]) {
+                    this.pendingResetScrollTop = true;
                     if (this.virtualScroll) {
                         // 仅虚拟/普通模式真正切换时重建，避免排序后数据刷新把排序态清掉
                         this.applyTableScrollMode(false);
                     }
+                    // 翻页/改 pageSize：主动多次复位，覆盖 CDK 异步渲染时序
+                    this.scheduleResetTableBodyScrollTop();
                     return;
                 }
                 if (!this.isCrossPageSelectLocal) {
                     this.resetStatus();
                 }
             }
-            if (changes["tableData"] && this.virtualScroll) {
-                // 数据刷新不强制重建，只在滚动模式变化时 remount
-                this.applyTableScrollMode(false);
+            if (changes["tableData"]) {
+                this.pendingResetScrollTop = true;
+                if (this.virtualScroll) {
+                    // 数据刷新不强制重建，只在滚动模式变化时 remount
+                    this.applyTableScrollMode(false);
+                }
+                // 数据更新后复位纵向滚动（含虚拟滚动场景）
+                this.scheduleResetTableBodyScrollTop();
             }
             if (changes["tableCols"] &&
                 JSON.stringify(changes["tableCols"].currentValue) !==
@@ -7819,16 +7831,32 @@
             enumerable: true,
             configurable: true
         });
-        Object.defineProperty(HdTableComponent.prototype, "useVirtualScroll", {
-            /** 当前页数据能完整展示时不启用虚拟滚动，避免少量数据也出现滚动条 */
+        /**
+         * 纵向可用高度扣减：按钮区/合计/分页等固定占位。
+         * 必须与 dealScroll / presetScrollBeforeRemount 使用同一套，否则会误判「能放下」而不设 scroll.y。
+         */
+        /**
+         * 纵向可用高度扣减：按钮区/合计/分页等固定占位。
+         * 必须与 dealScroll / presetScrollBeforeRemount 使用同一套，否则会误判「能放下」而不设 scroll.y。
+         * @private
+         * @return {?}
+         */
+        HdTableComponent.prototype.getScrollYMaxOffset = /**
+         * 纵向可用高度扣减：按钮区/合计/分页等固定占位。
+         * 必须与 dealScroll / presetScrollBeforeRemount 使用同一套，否则会误判「能放下」而不设 scroll.y。
+         * @private
+         * @return {?}
+         */
+        function () {
+            return (this.tableTotal ? 180 : 140) + 216;
+        };
+        Object.defineProperty(HdTableComponent.prototype, "needsVerticalScroll", {
+            /** 当前页内容高度是否超出视口（需要表内纵向滚动） */
             get: /**
-             * 当前页数据能完整展示时不启用虚拟滚动，避免少量数据也出现滚动条
+             * 当前页内容高度是否超出视口（需要表内纵向滚动）
              * @return {?}
              */
             function () {
-                if (!this.virtualScroll) {
-                    return false;
-                }
                 /** @type {?} */
                 var rowCount = this.tableData && this.tableData.content
                     ? this.tableData.content.length
@@ -7837,7 +7865,7 @@
                     return false;
                 }
                 /** @type {?} */
-                var maxOffset = this.tableTotal ? 180 : 140;
+                var maxOffset = this.getScrollYMaxOffset();
                 /** @type {?} */
                 var estimatedHeight = rowCount * this.effectiveVirtualItemSize;
                 if (typeof window !== "undefined") {
@@ -7848,6 +7876,21 @@
             enumerable: true,
             configurable: true
         });
+        Object.defineProperty(HdTableComponent.prototype, "useVirtualScroll", {
+            /** 当前页数据能完整展示时不启用虚拟滚动，避免少量数据也出现滚动条 */
+            get: /**
+             * 当前页数据能完整展示时不启用虚拟滚动，避免少量数据也出现滚动条
+             * @return {?}
+             */
+            function () {
+                if (!this.virtualScroll) {
+                    return false;
+                }
+                return this.needsVerticalScroll;
+            },
+            enumerable: true,
+            configurable: true
+        });
         /**
          * @param {?} col
          * @return {?}
@@ -8027,7 +8070,7 @@
          */
         function (useVirtual) {
             /** @type {?} */
-            var maxOffset = (this.tableTotal ? 180 : 140) + 216;
+            var maxOffset = this.getScrollYMaxOffset();
             /** @type {?} */
             var x = this.scroll ? this.scroll.x : null;
             if (this.virtualScroll && !useVirtual) {
@@ -8057,11 +8100,19 @@
             }
             if (this.virtualScroll) {
                 this.measureVirtualItemSize(true);
+                // 实测行高后可能从「能放下」变为「超出」，需切换滚动模式
+                if (this.useVirtualScroll) {
+                    this.applyTableScrollMode(false);
+                    return;
+                }
             }
             setTimeout((/**
              * @return {?}
              */
-            function () { return _this.syncHorizontalScroll(); }));
+            function () {
+                _this.syncHorizontalScroll();
+                _this.flushResetTableBodyScrollTop();
+            }));
         };
         /**
          * @param {?=} forceMeasure
@@ -8080,6 +8131,7 @@
                     this.dealScroll();
                     this.cdr.markForCheck();
                 }
+                this.flushResetTableBodyScrollTop();
                 return;
             }
             setTimeout((/**
@@ -8090,6 +8142,7 @@
                 var viewport = _this.nzTableComponent && _this.nzTableComponent.cdkVirtualScrollViewport;
                 if (!viewport) {
                     _this.syncHorizontalScroll();
+                    _this.flushResetTableBodyScrollTop();
                     return;
                 }
                 /** @type {?} */
@@ -8105,14 +8158,131 @@
                         _this.measureVirtualItemSize(forceMeasure);
                         _this.syncHorizontalScroll();
                         viewport.checkViewportSize();
+                        _this.flushResetTableBodyScrollTop();
                     }));
                 }
                 else {
                     viewport.checkViewportSize();
                     _this.syncHorizontalScroll();
+                    _this.flushResetTableBodyScrollTop();
                 }
             }));
         };
+        /** 数据刷新后将表体纵向滚动复位到顶部 */
+        /**
+         * 数据刷新后将表体纵向滚动复位到顶部
+         * @private
+         * @return {?}
+         */
+        HdTableComponent.prototype.resetTableBodyScrollTop = /**
+         * 数据刷新后将表体纵向滚动复位到顶部
+         * @private
+         * @return {?}
+         */
+        function () {
+            if (!this.nzTableComponent) {
+                return;
+            }
+            /** @type {?} */
+            var nzTable = (/** @type {?} */ (this.nzTableComponent));
+            /** @type {?} */
+            var viewport = this.nzTableComponent.cdkVirtualScrollViewport;
+            if (viewport) {
+                if (typeof ((/** @type {?} */ (viewport))).scrollToOffset === "function") {
+                    ((/** @type {?} */ (viewport))).scrollToOffset(0);
+                }
+                if (typeof ((/** @type {?} */ (viewport))).scrollToIndex === "function") {
+                    ((/** @type {?} */ (viewport))).scrollToIndex(0);
+                }
+                /** @type {?} */
+                var viewportEl = viewport.elementRef &&
+                    ((/** @type {?} */ (viewport.elementRef.nativeElement)));
+                if (viewportEl) {
+                    viewportEl.scrollTop = 0;
+                }
+            }
+            /** @type {?} */
+            var bodyCandidates = [
+                nzTable.mixTableBodyNativeElement,
+                nzTable.tableBodyNativeElement,
+                nzTable.tableBodyElement && nzTable.tableBodyElement.nativeElement,
+            ];
+            bodyCandidates.forEach((/**
+             * @param {?} el
+             * @return {?}
+             */
+            function (el) {
+                if (el) {
+                    el.scrollTop = 0;
+                }
+            }));
+            /** @type {?} */
+            var tableMain = nzTable.tableMainElement &&
+                ((/** @type {?} */ (nzTable.tableMainElement.nativeElement)));
+            if (!tableMain) {
+                return;
+            }
+            /** @type {?} */
+            var nodes = tableMain.querySelectorAll(".ant-table-body, cdk-virtual-scroll-viewport");
+            Array.prototype.forEach.call(nodes, (/**
+             * @param {?} el
+             * @return {?}
+             */
+            function (el) {
+                el.scrollTop = 0;
+            }));
+        };
+        /**
+         * 数据更新后多次尝试复位。
+         * ng-zorro 8 + CDK 虚拟滚动会在数据刷新后异步改写 scrollTop，单次复位经常被覆盖。
+         */
+        /**
+         * 数据更新后多次尝试复位。
+         * ng-zorro 8 + CDK 虚拟滚动会在数据刷新后异步改写 scrollTop，单次复位经常被覆盖。
+         * @private
+         * @return {?}
+         */
+        HdTableComponent.prototype.scheduleResetTableBodyScrollTop = /**
+         * 数据更新后多次尝试复位。
+         * ng-zorro 8 + CDK 虚拟滚动会在数据刷新后异步改写 scrollTop，单次复位经常被覆盖。
+         * @private
+         * @return {?}
+         */
+        function () {
+            var _this = this;
+            /** @type {?} */
+            var delays = [0, 50, 120];
+            delays.forEach((/**
+             * @param {?} ms
+             * @param {?} index
+             * @return {?}
+             */
+            function (ms, index) {
+                setTimeout((/**
+                 * @return {?}
+                 */
+                function () {
+                    _this.resetTableBodyScrollTop();
+                    if (index === delays.length - 1) {
+                        _this.pendingResetScrollTop = false;
+                    }
+                }), ms);
+            }));
+        };
+        /**
+         * @private
+         * @return {?}
+         */
+        HdTableComponent.prototype.flushResetTableBodyScrollTop = /**
+         * @private
+         * @return {?}
+         */
+        function () {
+            if (!this.pendingResetScrollTop) {
+                return;
+            }
+            this.resetTableBodyScrollTop();
+        };
         /** 未手动传 virtualItemSize 时，从已渲染行测量真实高度 */
         /**
          * 未手动传 virtualItemSize 时，从已渲染行测量真实高度
@@ -8853,8 +9023,7 @@
             }
             this.tableColWidthTotal = colWidth;
             /** @type {?} */
-            var maxOffset = this.tableTotal ? 180 : 140;
-            maxOffset += 216;
+            var maxOffset = this.getScrollYMaxOffset();
             /** @type {?} */
             var useVirtual = this.useVirtualScroll;
             /** @type {?} */
@@ -9215,6 +9384,12 @@
          * @private
          */
         HdTableComponent.prototype.tableColWidthTotal;
+        /**
+         * 数据更新后待复位纵向滚动位置
+         * @type {?}
+         * @private
+         */
+        HdTableComponent.prototype.pendingResetScrollTop;
         /**
          * 当前排序，表格重建后用于恢复表头排序态
          * @type {?}