fantasy-ngzorro 2.1.38 → 2.1.40

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) !==
@@ -8097,7 +8109,10 @@
             setTimeout((/**
              * @return {?}
              */
-            function () { return _this.syncHorizontalScroll(); }));
+            function () {
+                _this.syncHorizontalScroll();
+                _this.flushResetTableBodyScrollTop();
+            }));
         };
         /**
          * @param {?=} forceMeasure
@@ -8116,6 +8131,7 @@
                     this.dealScroll();
                     this.cdr.markForCheck();
                 }
+                this.flushResetTableBodyScrollTop();
                 return;
             }
             setTimeout((/**
@@ -8126,6 +8142,7 @@
                 var viewport = _this.nzTableComponent && _this.nzTableComponent.cdkVirtualScrollViewport;
                 if (!viewport) {
                     _this.syncHorizontalScroll();
+                    _this.flushResetTableBodyScrollTop();
                     return;
                 }
                 /** @type {?} */
@@ -8141,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];
+            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 时，从已渲染行测量真实高度
@@ -9250,6 +9384,12 @@
          * @private
          */
         HdTableComponent.prototype.tableColWidthTotal;
+        /**
+         * 数据更新后待复位纵向滚动位置
+         * @type {?}
+         * @private
+         */
+        HdTableComponent.prototype.pendingResetScrollTop;
         /**
          * 当前排序，表格重建后用于恢复表头排序态
          * @type {?}