deeptwins-engine-3d 0.1.63 → 0.1.64

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

@@ -0,0 +1,25 @@
+interface DecodedTile {
+    version: number;
+    z: number;
+    x: number;
+    y: number;
+    features: unknown[];
+}
+interface DecodeWorkerClientOptions {
+    workerUrl?: string;
+}
+declare class MvtVectorWorkerClient {
+    private _worker;
+    private _requestId;
+    private _pendingTasks;
+    constructor(options?: DecodeWorkerClientOptions);
+    decode(buffer: ArrayBuffer): Promise<DecodedTile>;
+    destroy(): void;
+    private _handleMessage;
+    private _handleError;
+    private _shutdown;
+    private _failAllPending;
+    private _toError;
+}
+export type { DecodedTile };
+export default MvtVectorWorkerClient;

package/dist/esm/tileLayer/MvtVectorWorkerClient.js

@@ -0,0 +1,126 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { getDeepTwinsFile } from "../tool/utils";
+var DEFAULT_MVT_VECTOR_WORKER_FILE = 'Workers/MvtVector.worker.js';
+var DEFAULT_MVT_VECTOR_WORKER_NAME = 'MvtVector.worker';
+// 创建解码 Worker。
+function createDecodeWorker(options) {
+  var workerUrl = options.workerUrl || getDeepTwinsFile(DEFAULT_MVT_VECTOR_WORKER_FILE);
+  return new Worker(workerUrl, {
+    type: 'module',
+    name: DEFAULT_MVT_VECTOR_WORKER_NAME
+  });
+}
+var MvtVectorWorkerClient = /*#__PURE__*/function () {
+  function MvtVectorWorkerClient() {
+    var _this = this;
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _classCallCheck(this, MvtVectorWorkerClient);
+    _defineProperty(this, "_worker", void 0);
+    _defineProperty(this, "_requestId", void 0);
+    _defineProperty(this, "_pendingTasks", void 0);
+    _defineProperty(this, "_handleMessage", function (event) {
+      var response = event.data;
+      var task = _this._pendingTasks.get(response.id);
+      if (!task) {
+        return;
+      }
+      _this._pendingTasks.delete(response.id);
+      if ('error' in response) {
+        task.reject(new Error(response.error));
+        return;
+      }
+      task.resolve(response.raw);
+    });
+    _defineProperty(this, "_handleError", function (event) {
+      var _event$error;
+      _this._shutdown(_this._toError((_event$error = event.error) !== null && _event$error !== void 0 ? _event$error : event.message, 'MVT 解码 Worker 运行失败'));
+    });
+    if (typeof Worker !== 'function') {
+      throw new Error('当前环境不支持 Worker');
+    }
+    this._worker = createDecodeWorker(options);
+    this._requestId = 0;
+    this._pendingTasks = new Map();
+    this._worker.addEventListener('message', this._handleMessage);
+    this._worker.addEventListener('error', this._handleError);
+  }
+
+  // 发送单个解码任务，结果通过结构化克隆回传主线程。
+  _createClass(MvtVectorWorkerClient, [{
+    key: "decode",
+    value: function decode(buffer) {
+      var _this2 = this;
+      var worker = this._worker;
+      if (!worker) {
+        return Promise.reject(new Error('MVT 解码 Worker 已销毁'));
+      }
+      var id = ++this._requestId;
+      return new Promise(function (resolve, reject) {
+        _this2._pendingTasks.set(id, {
+          resolve: resolve,
+          reject: reject
+        });
+        try {
+          worker.postMessage({
+            id: id,
+            buffer: buffer
+          }, [buffer]);
+        } catch (error) {
+          _this2._pendingTasks.delete(id);
+          reject(_this2._toError(error, '发送 MVT 解码任务失败'));
+        }
+      });
+    }
+
+    // 销毁 Worker，并让所有挂起任务立即失败。
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this._shutdown(new Error('MVT 解码 Worker 已销毁'));
+    }
+  }, {
+    key: "_shutdown",
+    value: function _shutdown(reason) {
+      if (!this._worker) {
+        return;
+      }
+      this._worker.removeEventListener('message', this._handleMessage);
+      this._worker.removeEventListener('error', this._handleError);
+      this._worker.terminate();
+      this._worker = null;
+      this._failAllPending(reason);
+    }
+  }, {
+    key: "_failAllPending",
+    value: function _failAllPending(reason) {
+      var pendingTasks = [];
+      this._pendingTasks.forEach(function (task) {
+        pendingTasks.push(task);
+      });
+      this._pendingTasks.clear();
+      for (var _i = 0, _pendingTasks = pendingTasks; _i < _pendingTasks.length; _i++) {
+        var task = _pendingTasks[_i];
+        task.reject(reason);
+      }
+    }
+  }, {
+    key: "_toError",
+    value: function _toError(error, fallbackMessage) {
+      if (error instanceof Error) {
+        return error;
+      }
+      if (typeof error === 'string' && error.length > 0) {
+        return new Error(error);
+      }
+      return new Error(fallbackMessage);
+    }
+  }]);
+  return MvtVectorWorkerClient;
+}();
+export default MvtVectorWorkerClient;