deeptwins-engine-3d 0.1.65 → 0.1.67

package/dist/esm/tileLayer/MvtVectorLoad.d.ts

@@ -1,3 +1,4 @@
+/// <reference path="../typings.d.ts" />
 import * as Cesium from 'deeptwins-cesium';
 import { MapContext } from '../map/Map';
 type TileState = 'none' | 'loading' | 'loaded' | 'error';
@@ -151,8 +152,13 @@ declare class MvtVectorLoad {
     _tilesToUpdate: VectorLoadTile[];
     _loadedTiles: Record<string, LoadedTile>;
     _pendingTiles: Map<string, Promise<LoadedTile>>;
+    private _pendingRequestControllers;
+    private _pendingRequestTiles;
     private _cacheOrder;
     _requestToken: number;
+    private _requestQueue;
+    private _queuedTileKeys;
+    private _activeRequestCount;
     private _levelZeroMaximumGeometricError;
     private _decodeWithWorker;
     private _autoDisplayLayers;
@@ -177,6 +183,9 @@ declare class MvtVectorLoad {
     private _doInit;
     private _validateOptions;
     private _emitError;
+    private _isAbortError;
+    private _markTileLoading;
+    private _resetTileRequestState;
     private _createRootTiles;
     private _getTileKey;
     private _touchTileCache;
@@ -211,11 +220,14 @@ declare class MvtVectorLoad {
     private _loadTile;
     tileToGeoJSON(tile: LoadedTile): TileGeoJSONResult;
     update(frameState: FrameStateLike): void;
+    private _cancelStaleRequests;
     private _updateTiles;
+    private _drainRequestQueue;
     private _loadVisibleTile;
     getLoadedTiles(): LoadedTile[];
     getTile(x: number, y: number, z: number): LoadedTile | undefined;
     clearCache(): void;
+    private _abortAllPendingRequests;
     private _resetTileStates;
     destroy(): void;
     isDestroyed(): boolean;
@@ -233,6 +245,7 @@ declare class VectorLoadTile {
     distanceToCamera: number;
     visibility: Cesium.Intersect;
     state: TileState;
+    requestVersion: number;
     constructor(options: VectorLoadTileOptions);
     createChildren(): void;
     visit(frameState: FrameStateLike, visitor: TileVisitor, getScreenSpaceError: ScreenSpaceErrorCalculator): void;

package/dist/esm/tileLayer/MvtVectorLoad.js

@@ -46,6 +46,9 @@ function createListenerRegistry() {
   };
 }
 
+// 最大并发请求数，默认 6。
+var MAX_CONCURRENT_TILE_REQUESTS = 6;
+
 // 矢量瓦片加载器
 var MvtVectorLoad = /*#__PURE__*/function () {
   function MvtVectorLoad(map) {
@@ -97,10 +100,20 @@ var MvtVectorLoad = /*#__PURE__*/function () {
     _defineProperty(this, "_loadedTiles", void 0);
     // 正在请求中的瓦片 Promise，避免重复请求。
     _defineProperty(this, "_pendingTiles", void 0);
+    // 正在执行网络请求的瓦片控制器，用于主动取消过期请求。
+    _defineProperty(this, "_pendingRequestControllers", void 0);
+    // 正在执行网络请求的瓦片对象，用于回退状态和日志定位。
+    _defineProperty(this, "_pendingRequestTiles", void 0);
     // LRU 缓存访问顺序，越靠后表示越新。
     _defineProperty(this, "_cacheOrder", void 0);
     // 请求版本号，用于在清缓存后废弃旧请求结果。
     _defineProperty(this, "_requestToken", void 0);
+    // 等待发起请求的瓦片队列，按进入顺序消费。
+    _defineProperty(this, "_requestQueue", void 0);
+    // 队列中的瓦片 key 集合，避免同一瓦片重复排队。
+    _defineProperty(this, "_queuedTileKeys", void 0);
+    // 当前已占用的请求槽位数量，限制瞬时并发数。
+    _defineProperty(this, "_activeRequestCount", void 0);
     // 第 0 层瓦片的几何误差缓存。
     _defineProperty(this, "_levelZeroMaximumGeometricError", void 0);
     // 是否优先使用 Worker 解析 MVT 二进制。
@@ -141,8 +154,13 @@ var MvtVectorLoad = /*#__PURE__*/function () {
     this._tilesToUpdate = [];
     this._loadedTiles = {};
     this._pendingTiles = new Map();
+    this._pendingRequestControllers = new Map();
+    this._pendingRequestTiles = new Map();
     this._cacheOrder = new Map();
     this._requestToken = 0;
+    this._requestQueue = [];
+    this._queuedTileKeys = new Set();
+    this._activeRequestCount = 0;
     this._levelZeroMaximumGeometricError = null;
     this._decodeWorkerClient = null;
     this._listenerRegistry = createListenerRegistry();
@@ -394,6 +412,30 @@ var MvtVectorLoad = /*#__PURE__*/function () {
       return error;
     }
 
+    // 判断错误是否来自 AbortController 主动取消。
+  }, {
+    key: "_isAbortError",
+    value: function _isAbortError(error) {
+      return error instanceof Error && error.name === 'AbortError';
+    }
+
+    // 让瓦片进入新的加载批次，并返回本次批次号用于并发回写保护。
+  }, {
+    key: "_markTileLoading",
+    value: function _markTileLoading(tile) {
+      tile.requestVersion += 1;
+      tile.state = 'loading';
+      return tile.requestVersion;
+    }
+
+    // 让瓦片回到未加载状态，并废弃此前尚未完成的批次回调。
+  }, {
+    key: "_resetTileRequestState",
+    value: function _resetTileRequestState(tile) {
+      tile.requestVersion += 1;
+      tile.state = 'none';
+    }
+
     // 创建第 0 层根瓦片，作为后续遍历入口。
   }, {
     key: "_createRootTiles",
@@ -827,7 +869,7 @@ var MvtVectorLoad = /*#__PURE__*/function () {
       for (var index = 0; index < queue.length; index += 1) {
         var _tile6 = queue[index];
         if (keySet.has(_tile6.key)) {
-          _tile6.state = 'none';
+          this._resetTileRequestState(_tile6);
         }
         var _iterator8 = _createForOfIteratorHelper(_tile6.children),
           _step8;
@@ -952,14 +994,16 @@ var MvtVectorLoad = /*#__PURE__*/function () {
   }, {
     key: "_requestTile",
     value: function () {
-      var _requestTile2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(x, y, z) {
+      var _requestTile2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(x, y, z, signal) {
         var url, response, buffer;
         return _regeneratorRuntime().wrap(function _callee3$(_context3) {
           while (1) switch (_context3.prev = _context3.next) {
             case 0:
               url = this._buildTileUrl(x, y, z);
               _context3.next = 3;
-              return fetch(url);
+              return fetch(url, {
+                signal: signal
+              });
             case 3:
               response = _context3.sent;
               if (response.ok) {
@@ -991,7 +1035,7 @@ var MvtVectorLoad = /*#__PURE__*/function () {
           }
         }, _callee3, this);
       }));
-      function _requestTile(_x2, _x3, _x4) {
+      function _requestTile(_x2, _x3, _x4, _x5) {
         return _requestTile2.apply(this, arguments);
       }
       return _requestTile;
@@ -999,9 +1043,9 @@ var MvtVectorLoad = /*#__PURE__*/function () {
   }, {
     key: "_loadTile",
     value: function () {
-      var _loadTile2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(x, y, z) {
+      var _loadTile2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(tile) {
         var _this10 = this;
-        var key, cached, pending, requestToken, request;
+        var x, y, z, key, cached, pending, requestToken, controller, request;
         return _regeneratorRuntime().wrap(function _callee4$(_context4) {
           while (1) switch (_context4.prev = _context4.next) {
             case 0:
@@ -1009,13 +1053,13 @@ var MvtVectorLoad = /*#__PURE__*/function () {
               return this.init();
             case 2:
               this._validateOptions();
+              x = tile.x, y = tile.y, z = tile.z, key = tile.key;
               if (!(z < this.minzoom || z > this.maximumLevel)) {
-                _context4.next = 5;
+                _context4.next = 6;
                 break;
               }
               throw this._emitError(new Error("\u74E6\u7247\u5C42\u7EA7 ".concat(z, " \u8D85\u51FA\u8303\u56F4 [").concat(this.minzoom, ", ").concat(this.maximumLevel, "]")));
-            case 5:
-              key = this._getTileKey(x, y, z);
+            case 6:
               cached = this._loadedTiles[key];
               if (!cached) {
                 _context4.next = 10;
@@ -1033,8 +1077,9 @@ var MvtVectorLoad = /*#__PURE__*/function () {
             case 13:
               // requestToken 用于在 clearCache 后废弃旧请求，避免过期结果再次写回缓存。
               requestToken = this._requestToken;
-              request = this._requestTile(x, y, z).then(function (tile) {
-                if (requestToken !== _this10._requestToken || _this10._destroyed) {
+              controller = new AbortController();
+              request = this._requestTile(x, y, z, controller.signal).then(function (tile) {
+                if (controller.signal.aborted || requestToken !== _this10._requestToken || _this10._destroyed) {
                   return tile;
                 }
                 _this10._loadedTiles[key] = tile;
@@ -1044,19 +1089,33 @@ var MvtVectorLoad = /*#__PURE__*/function () {
                 _this10._syncTileDisplayState(_this10._tilesToUpdate);
                 return tile;
               }).catch(function (error) {
-                throw _this10._emitError(error);
+                var normalizedError = _this10._toError(error, '加载 MVT 瓦片失败');
+                if (controller.signal.aborted || _this10._isAbortError(normalizedError)) {
+                  throw normalizedError;
+                }
+                throw _this10._emitError(normalizedError);
               }).finally(function () {
-                _this10._pendingTiles.delete(key);
+                if (_this10._pendingTiles.get(key) === request) {
+                  _this10._pendingTiles.delete(key);
+                }
+                if (_this10._pendingRequestControllers.get(key) === controller) {
+                  _this10._pendingRequestControllers.delete(key);
+                }
+                if (_this10._pendingRequestTiles.get(key) === tile) {
+                  _this10._pendingRequestTiles.delete(key);
+                }
               });
               this._pendingTiles.set(key, request);
+              this._pendingRequestControllers.set(key, controller);
+              this._pendingRequestTiles.set(key, tile);
               return _context4.abrupt("return", request);
-            case 17:
+            case 20:
             case "end":
               return _context4.stop();
           }
         }, _callee4, this);
       }));
-      function _loadTile(_x5, _x6, _x7) {
+      function _loadTile(_x6) {
         return _loadTile2.apply(this, arguments);
       }
       return _loadTile;
@@ -1086,59 +1145,163 @@ var MvtVectorLoad = /*#__PURE__*/function () {
         return;
       }
       var tilesToUpdate = this._getTilesToUpdate(frameState);
+      var targetTileKeys = new Set(tilesToUpdate.map(function (tile) {
+        return tile.key;
+      }));
+      this._cancelStaleRequests(targetTileKeys);
       this._syncTileDisplayState(tilesToUpdate);
       this._updateTiles(tilesToUpdate);
     }
 
-    // 遍历本帧候选瓦片，并触发尚未加载的可见瓦片请求。
+    // 取消当前视口之外的活跃请求，并丢弃尚未发出的过期队列项。
   }, {
-    key: "_updateTiles",
-    value: function _updateTiles(tilesToUpdate) {
-      var _iterator9 = _createForOfIteratorHelper(tilesToUpdate),
+    key: "_cancelStaleRequests",
+    value: function _cancelStaleRequests(targetTileKeys) {
+      var _iterator9 = _createForOfIteratorHelper(this._pendingRequestControllers.entries()),
         _step9;
       try {
         for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
-          var _tile7 = _step9.value;
-          if (_tile7.state !== 'none') {
+          var _step9$value = _slicedToArray(_step9.value, 2),
+            key = _step9$value[0],
+            controller = _step9$value[1];
+          if (targetTileKeys.has(key)) {
             continue;
           }
-          void this._loadVisibleTile(_tile7);
+          var pendingTile = this._pendingRequestTiles.get(key);
+          this._pendingTiles.delete(key);
+          this._pendingRequestControllers.delete(key);
+          this._pendingRequestTiles.delete(key);
+          controller.abort();
+          if (pendingTile) {
+            this._resetTileRequestState(pendingTile);
+          }
         }
       } catch (err) {
         _iterator9.e(err);
       } finally {
         _iterator9.f();
       }
+      if (this._requestQueue.length === 0) {
+        return;
+      }
+      var nextQueue = [];
+      this._queuedTileKeys.clear();
+      var _iterator10 = _createForOfIteratorHelper(this._requestQueue),
+        _step10;
+      try {
+        for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+          var _tile7 = _step10.value;
+          if (!targetTileKeys.has(_tile7.key)) {
+            this._resetTileRequestState(_tile7);
+            continue;
+          }
+          nextQueue.push(_tile7);
+          this._queuedTileKeys.add(_tile7.key);
+        }
+      } catch (err) {
+        _iterator10.e(err);
+      } finally {
+        _iterator10.f();
+      }
+      this._requestQueue = nextQueue;
+    }
+
+    // 把尚未加载的可见瓦片加入请求队列，并在并发上限内逐个拉起。
+  }, {
+    key: "_updateTiles",
+    value: function _updateTiles(tilesToUpdate) {
+      var _iterator11 = _createForOfIteratorHelper(tilesToUpdate),
+        _step11;
+      try {
+        for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+          var _tile8 = _step11.value;
+          if (_tile8.state !== 'none') {
+            continue;
+          }
+          this._markTileLoading(_tile8);
+          this._requestQueue.push(_tile8);
+          this._queuedTileKeys.add(_tile8.key);
+        }
+      } catch (err) {
+        _iterator11.e(err);
+      } finally {
+        _iterator11.f();
+      }
+      this._drainRequestQueue();
+    }
+
+    // 在固定并发数内消费排队中的瓦片请求。
+  }, {
+    key: "_drainRequestQueue",
+    value: function _drainRequestQueue() {
+      var _this11 = this;
+      if (this._destroyed) {
+        return;
+      }
+      while (this._activeRequestCount < MAX_CONCURRENT_TILE_REQUESTS && this._requestQueue.length > 0) {
+        var _tile9 = this._requestQueue.shift();
+        if (!_tile9) {
+          continue;
+        }
+        this._queuedTileKeys.delete(_tile9.key);
+        if (_tile9.state !== 'loading') {
+          continue;
+        }
+        var requestVersion = _tile9.requestVersion;
+        this._activeRequestCount += 1;
+        void this._loadVisibleTile(_tile9, requestVersion).finally(function () {
+          _this11._activeRequestCount = Math.max(_this11._activeRequestCount - 1, 0);
+          _this11._drainRequestQueue();
+        });
+      }
     }
 
     // 加载当前可见瓦片，并同步维护瓦片状态。
   }, {
     key: "_loadVisibleTile",
     value: function () {
-      var _loadVisibleTile2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(tile) {
+      var _loadVisibleTile2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(tile, requestVersion) {
         return _regeneratorRuntime().wrap(function _callee5$(_context5) {
           while (1) switch (_context5.prev = _context5.next) {
             case 0:
-              tile.state = 'loading';
-              _context5.prev = 1;
-              _context5.next = 4;
-              return this._loadTile(tile.x, tile.y, tile.z);
-            case 4:
+              _context5.prev = 0;
+              _context5.next = 3;
+              return this._loadTile(tile);
+            case 3:
+              if (!(tile.requestVersion !== requestVersion)) {
+                _context5.next = 5;
+                break;
+              }
+              return _context5.abrupt("return");
+            case 5:
               tile.state = 'loaded';
-              _context5.next = 11;
+              _context5.next = 17;
               break;
-            case 7:
-              _context5.prev = 7;
-              _context5.t0 = _context5["catch"](1);
+            case 8:
+              _context5.prev = 8;
+              _context5.t0 = _context5["catch"](0);
+              if (!(tile.requestVersion !== requestVersion)) {
+                _context5.next = 12;
+                break;
+              }
+              return _context5.abrupt("return");
+            case 12:
+              if (!this._isAbortError(_context5.t0)) {
+                _context5.next = 15;
+                break;
+              }
+              tile.state = 'none';
+              return _context5.abrupt("return");
+            case 15:
               tile.state = 'error';
               console.error("\u52A0\u8F7D\u5931\u8D25 [".concat(tile.x, ", ").concat(tile.y, ", ").concat(tile.z, "]"), _context5.t0);
-            case 11:
+            case 17:
             case "end":
               return _context5.stop();
           }
-        }, _callee5, this, [[1, 7]]);
+        }, _callee5, this, [[0, 8]]);
       }));
-      function _loadVisibleTile(_x8) {
+      function _loadVisibleTile(_x7, _x8) {
         return _loadVisibleTile2.apply(this, arguments);
       }
       return _loadVisibleTile;
@@ -1162,15 +1325,16 @@ var MvtVectorLoad = /*#__PURE__*/function () {
     value: function clearCache() {
       this._requestToken += 1;
       var cachedTiles = Object.values(this._loadedTiles);
+      this._abortAllPendingRequests();
       this._hideAllDisplayedTiles();
       for (var _i4 = 0, _cachedTiles = cachedTiles; _i4 < _cachedTiles.length; _i4++) {
-        var _tile8 = _cachedTiles[_i4];
-        var key = this._getTileKey(_tile8.x, _tile8.y, _tile8.z);
+        var _tile10 = _cachedTiles[_i4];
+        var key = this._getTileKey(_tile10.x, _tile10.y, _tile10.z);
         this.tileEvictEvent.raiseEvent({
           key: key,
-          x: _tile8.x,
-          y: _tile8.y,
-          z: _tile8.z
+          x: _tile10.x,
+          y: _tile10.y,
+          z: _tile10.z
         });
         this._removeManagedTileLayers(key);
       }
@@ -1181,28 +1345,57 @@ var MvtVectorLoad = /*#__PURE__*/function () {
       this._resetTileStates();
     }
 
+    // 取消全部进行中与排队中的请求，供清缓存和销毁时统一复用。
+  }, {
+    key: "_abortAllPendingRequests",
+    value: function _abortAllPendingRequests() {
+      this._requestQueue.length = 0;
+      this._queuedTileKeys.clear();
+      var _iterator12 = _createForOfIteratorHelper(this._pendingRequestControllers.entries()),
+        _step12;
+      try {
+        for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
+          var _step12$value = _slicedToArray(_step12.value, 2),
+            key = _step12$value[0],
+            controller = _step12$value[1];
+          var pendingTile = this._pendingRequestTiles.get(key);
+          this._pendingTiles.delete(key);
+          this._pendingRequestControllers.delete(key);
+          this._pendingRequestTiles.delete(key);
+          controller.abort();
+          if (pendingTile) {
+            this._resetTileRequestState(pendingTile);
+          }
+        }
+      } catch (err) {
+        _iterator12.e(err);
+      } finally {
+        _iterator12.f();
+      }
+    }
+
     // 把整棵瓦片树的状态恢复为未加载。
   }, {
     key: "_resetTileStates",
     value: function _resetTileStates() {
       var queue = _toConsumableArray(this._rootTiles);
       while (queue.length > 0) {
-        var _tile9 = queue.shift();
-        if (!_tile9) {
+        var _tile11 = queue.shift();
+        if (!_tile11) {
           continue;
         }
-        _tile9.state = 'none';
-        var _iterator10 = _createForOfIteratorHelper(_tile9.children),
-          _step10;
+        this._resetTileRequestState(_tile11);
+        var _iterator13 = _createForOfIteratorHelper(_tile11.children),
+          _step13;
         try {
-          for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
-            var child = _step10.value;
+          for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
+            var child = _step13.value;
             queue.push(child);
           }
         } catch (err) {
-          _iterator10.e(err);
+          _iterator13.e(err);
         } finally {
-          _iterator10.f();
+          _iterator13.f();
         }
       }
     }
@@ -1263,6 +1456,8 @@ var VectorLoadTile = /*#__PURE__*/function () {
     _defineProperty(this, "visibility", void 0);
     // 当前瓦片的加载状态。
     _defineProperty(this, "state", void 0);
+    // 当前瓦片的请求批次号，用于丢弃过期的异步回写。
+    _defineProperty(this, "requestVersion", void 0);
     this.x = options.x;
     this.y = options.y;
     this.z = options.z;
@@ -1281,6 +1476,7 @@ var VectorLoadTile = /*#__PURE__*/function () {
     this.distanceToCamera = 0;
     this.visibility = Cesium.Intersect.INSIDE;
     this.state = 'none';
+    this.requestVersion = 0;
   }
 
   // 创建四个子瓦片；如果已经创建过则直接返回。

package/dist/esm/tool/common.d.ts

@@ -1,3 +1,4 @@
+/// <reference path="../typings.d.ts" />
 import * as Cesium from 'deeptwins-cesium';
 import { Cartesian2, Cartesian3 } from 'deeptwins-cesium';
 import { MapContext } from '../map/Map';

package/dist/esm/tool/utils.d.ts

@@ -1,3 +1,4 @@
+/// <reference path="../typings.d.ts" />
 import * as Cesium from 'deeptwins-cesium';
 import { Cartesian3 } from 'deeptwins-cesium';
 export declare const loadUMDModule: (url: string, moduleName: string) => Promise<unknown>;

package/dist/esm/typings.d.ts

@@ -13,3 +13,11 @@ declare const VERSION: string;
 // 在esm中会赋值给window.CESIUM_BASE_URL 使用本地代理
 // 在umd中会使用https://unpkg.com上相应版本的地址
 declare const DEEP_TWINS_BASE_URL: string;
+declare module 'deeptwins-cesium' {
+  export const BufferUsage: any;
+  export const DrawCommand: any;
+  export const Pass: any;
+  export const RenderState: any;
+  export const ShaderProgram: any;
+  export const VertexArray: any;
+}

package/dist/esm/visualization/BaseHeatmap.d.ts

@@ -22,5 +22,10 @@ export default class BaseHeatmap {
     _translatePositions(): void;
     private _computeBound;
     private _toRectangle;
+    private _getHeatmapConfig;
+    _getHeatValueRange(): {
+        minValue: any;
+        maxValue: number;
+    };
     destroy(): void;
 }