@realsee/dnalogel 0.1.0

package/plugins/floorplan/utils/formatData.d.ts

@@ -0,0 +1,5 @@
+import { Five } from '@realsee/five';
+import { FloorplanData, FloorplanExtraObject, FloorplanExtraObject3D } from '../typings/floorplanData';
+import { FloorplanServerData } from '../typings/floorplanServerData';
+export default function formatData(data: FloorplanServerData): Promise<FloorplanData>;
+export declare function formatExtraObjects(data: FloorplanExtraObject3D[], five: Five, floorplanData: FloorplanData): FloorplanExtraObject[];

package/plugins/floorplan/utils/formatData.js

@@ -0,0 +1,220 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = formatData;
+exports.formatExtraObjects = formatExtraObjects;
+
+var _floorplanExtraObject = require("../Assets/floorplanExtraObject");
+
+var _formatPosition = require("./formatPosition");
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function formatOutlines(_x) {
+  return _formatOutlines.apply(this, arguments);
+}
+
+function _formatOutlines() {
+  _formatOutlines = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(outlines) {
+    var headers, getOutlineItem, svgOutlineItems;
+    return regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            headers = new Headers({
+              'Content-Type': 'text/plain'
+            });
+
+            getOutlineItem = /*#__PURE__*/function () {
+              var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(item) {
+                var outlineItem, svgContent;
+                return regeneratorRuntime.wrap(function _callee$(_context) {
+                  while (1) {
+                    switch (_context.prev = _context.next) {
+                      case 0:
+                        outlineItem = {
+                          index: item.index,
+                          url: item.url,
+                          svgUrl: item.svg_url
+                        };
+
+                        if (!item.svg_url) {
+                          _context.next = 6;
+                          break;
+                        }
+
+                        _context.next = 4;
+                        return fetch(item.svg_url, {
+                          headers: headers
+                        }).then(function (res) {
+                          return res.text();
+                        });
+
+                      case 4:
+                        svgContent = _context.sent;
+                        outlineItem.svgContent = svgContent;
+
+                      case 6:
+                        return _context.abrupt("return", outlineItem);
+
+                      case 7:
+                      case "end":
+                        return _context.stop();
+                    }
+                  }
+                }, _callee);
+              }));
+
+              return function getOutlineItem(_x3) {
+                return _ref.apply(this, arguments);
+              };
+            }();
+
+            _context2.next = 4;
+            return Promise.all(outlines.map(getOutlineItem));
+
+          case 4:
+            svgOutlineItems = _context2.sent;
+            return _context2.abrupt("return", svgOutlineItems);
+
+          case 6:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _formatOutlines.apply(this, arguments);
+}
+
+function formatRoom(data) {
+  var floorplanRoomItem = {
+    id: data.id,
+    size: data.size,
+    name: data.name,
+    path: data.path,
+    roomType: data.room_type,
+    floorType: data.floor_type,
+    roomLabel: {
+      position: data.room_label.position,
+      positionInImage: data.room_label.position_in_image
+    },
+    observerIndexs: data.observer_indexs
+  };
+  return floorplanRoomItem;
+}
+
+function formatFloorData(_data) {
+  return {
+    floorName: _data.floor_name,
+    floorIndex: _data.floor_index,
+    rooms: _data.rooms.map(formatRoom)
+  };
+}
+
+function formateFloorplanObserver(data) {
+  var floorplanObserver = {
+    index: data.index,
+    floorIndex: data.floor_index,
+    position: data.position,
+    positionInImage: data.position_in_image
+  };
+  return floorplanObserver;
+}
+
+function formatFloorplanEntrance(data) {
+  var floorplanEntrance = {
+    rad: data.rad,
+    position: data.position,
+    positionInImage: data.position_in_image,
+    northRad: data.north_rad,
+    roomId: data.room_id,
+    floorIndex: data.floor_index
+  };
+  return floorplanEntrance;
+}
+
+function formatData(_x2) {
+  return _formatData.apply(this, arguments);
+}
+
+function _formatData() {
+  _formatData = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(data) {
+    var outlines, bounding, floorDatas, entrance, floorplanData;
+    return regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.next = 2;
+            return formatOutlines(data.outlines);
+
+          case 2:
+            outlines = _context3.sent;
+            bounding = data.computed_data.bounding;
+            floorDatas = data.computed_data.floor_datas.map(formatFloorData);
+            entrance = data.computed_data.entrance ? formatFloorplanEntrance(data.computed_data.entrance) : null;
+            floorplanData = {
+              outlines: outlines,
+              entrance: entrance,
+              bounding: bounding,
+              floorDatas: floorDatas,
+              observers: data.computed_data.observers.map(formateFloorplanObserver)
+            };
+            return _context3.abrupt("return", floorplanData);
+
+          case 8:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _formatData.apply(this, arguments);
+}
+
+function formatExtraObjects(data, five, floorplanData) {
+  var extraObjects = data.map(function (object) {
+    var _object$position = _slicedToArray(object.position, 3),
+        x = _object$position[0],
+        y = _object$position[1],
+        z = _object$position[2];
+
+    var position = {
+      x: x,
+      y: y,
+      z: z
+    };
+    var icon = object.icon ? object.icon : {
+      url: _floorplanExtraObject.FLOORPLANE_EXTRA_OBJECT_IMAGE,
+      width: 45,
+      height: 48
+    };
+    var floorIndex = (0, _formatPosition.getFloorIndexFromModelPosition)(position, five);
+    var floorplanPosition = (0, _formatPosition.modelPosition2FloorplanPosition)(position, floorplanData);
+    var floorplanImagePosition = (0, _formatPosition.floorplanPosition2ImagePosition)(floorplanPosition, floorplanData);
+    return {
+      floorIndex: floorIndex,
+      icon: icon,
+      id: object.id,
+      position: floorplanPosition,
+      positionInImage: floorplanImagePosition
+    };
+  });
+  return extraObjects;
+}

package/plugins/floorplan/utils/formatPosition.d.ts

@@ -0,0 +1,37 @@
+import { Five } from '@realsee/five';
+import { Vector2 } from '../../../typings/math.type';
+import { FloorplanData } from '../typings/floorplanData';
+import { FloorplanBounding } from '../typings/floorplanData';
+export declare function pathD(points: Vector2[], options?: {
+    needZ?: boolean;
+    needA?: Record<number, string>;
+    format?: (vector: Vector2) => Vector2;
+}): string;
+/** 把户型图上点点位转换到 SVG 上的点位 */
+export default function formatFloorplanPoint({ x, y }: Vector2, pxmm: number, bounding: FloorplanBounding): {
+    x: number;
+    y: number;
+};
+/** 模型坐标转户型图坐标 */
+export declare function modelPosition2FloorplanPosition(position: {
+    x: number;
+    y: number;
+    z: number;
+}, floorplanData: FloorplanData): {
+    x: number;
+    y: number;
+};
+/** 户型图点位转在图片上的相对坐标 */
+export declare function floorplanPosition2ImagePosition(position: {
+    x: number;
+    y: number;
+}, floorplanData: FloorplanData): {
+    x: number;
+    y: number;
+};
+/** 求三维坐标点所在的楼层 */
+export declare function getFloorIndexFromModelPosition(position: {
+    x: number;
+    y: number;
+    z: number;
+}, five: Five): number;

package/plugins/floorplan/utils/formatPosition.js

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = formatFloorplanPoint;
+exports.floorplanPosition2ImagePosition = floorplanPosition2ImagePosition;
+exports.getFloorIndexFromModelPosition = getFloorIndexFromModelPosition;
+exports.modelPosition2FloorplanPosition = modelPosition2FloorplanPosition;
+exports.pathD = pathD;
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function pathD(points) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var d = '';
+  var needZ = options.needZ,
+      needA = options.needA;
+  if (needZ) points = points.concat(points[0]);
+  points.forEach(function (_point, index) {
+    var _ref = options.format ? options.format(_point) : _point,
+        x = _ref.x,
+        y = _ref.y;
+
+    var point = x + ',' + y;
+    if (index == 0) return d += 'M' + point;
+    if (needA && needA[index]) return d += 'A' + needA[index] + ',' + point;
+    return d += 'L' + point;
+  });
+  return d + (needZ ? 'Z' : '');
+}
+/** 把户型图上点点位转换到 SVG 上的点位 */
+
+
+function formatFloorplanPoint(_ref2, pxmm, bounding) {
+  var x = _ref2.x,
+      y = _ref2.y;
+  var max = bounding.max,
+      min = bounding.min;
+  return {
+    x: (x - min.x) * pxmm,
+    y: (max.y - y) * pxmm
+  };
+}
+/** 模型坐标转户型图坐标 */
+
+
+function modelPosition2FloorplanPosition(position, floorplanData) {
+  var x = position.x * 1000 + floorplanData.bounding.origin.x;
+  var y = -position.z * 1000 + floorplanData.bounding.origin.y;
+  return {
+    x: x,
+    y: y
+  };
+}
+/** 户型图点位转在图片上的相对坐标 */
+
+
+function floorplanPosition2ImagePosition(position, floorplanData) {
+  var bounding = floorplanData.bounding;
+  var boundingWidth = bounding.max.x - bounding.min.x;
+  var boundingHeight = bounding.max.y - bounding.min.y;
+  return {
+    x: (position.x - bounding.min.x) / boundingWidth,
+    y: (bounding.max.y - position.y) / boundingHeight
+  };
+}
+/** 求三维坐标点所在的楼层 */
+
+
+function getFloorIndexFromModelPosition(position, five) {
+  var floorIndex = Math.max.apply(Math, _toConsumableArray(five.work.observers.map(function (observer) {
+    if (position.z >= observer.standingPosition.z) return observer.floorIndex;
+    return 0;
+  })));
+  return floorIndex;
+}

package/shared-utils/Preloader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 预载器
+ */
+export declare const Preloader: {
+    blob: (url: string) => Promise<string>;
+};

package/shared-utils/Preloader.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Preloader = void 0;
+
+/**
+ * 预载器
+ */
+var Preloader = {
+  blob: function blob(url) {
+    var noop = function noop() {
+      return null;
+    };
+
+    return new Promise(function (resolve, reject) {
+      var xhr = new XMLHttpRequest();
+
+      var clear = function clear() {
+        xhr.ontimeout = noop;
+        xhr.onreadystatechange = noop;
+        xhr.onprogress = noop;
+        xhr.onabort = noop;
+      };
+
+      xhr.ontimeout = function () {
+        reject(new Error('timeout'));
+        clear();
+      };
+
+      xhr.onreadystatechange = function () {
+        if (xhr.readyState !== 4) return;
+        if (xhr.status === 0 && !xhr.response) return;
+
+        if (xhr.status === 200 || xhr.status === 0) {
+          resolve(xhr.response);
+          clear();
+        } else {
+          reject(new Error('status:' + xhr.status));
+          clear();
+        }
+      };
+
+      xhr.open('GET', url, true);
+      xhr.responseType = 'blob';
+      xhr.send(null);
+    });
+  }
+};
+exports.Preloader = Preloader;

package/shared-utils/Subscribe.d.ts

@@ -0,0 +1,45 @@
+declare const __EVENT__ = "__events__";
+/**
+ * 订阅类。
+ * 观察者模式（供前端使用），Node端推荐<a href="https://nodejs.org/api/events.html#events_class_eventemitter">EventEmitter</a>。
+ */
+export default class Subscribe {
+    private [__EVENT__];
+    constructor();
+    /**
+     * 判断是否注册时事件
+     * @param  {string|[string]}  name     事件类型
+     */
+    hasListener(name: string): any;
+    /**
+     * 注册事件
+     * @param  {string|[string]}  names    事件类型
+     * @param  {function}         callback 事件回调函数
+     * @param  {any}              context  事件回调函数调用的上下文
+     * @param  {boolean}          once     是否只执行一次
+     */
+    on(names: string | string[], callback: (...args: any[]) => void, context?: any, once?: boolean): () => this | undefined;
+    /**
+     * 注册事件(是否只执行一次)
+     * @param  {string|[string]}  names    事件类型
+     * @param  {function}         callback 事件回调函数
+     * @param  {any}              context  事件回调函数调用的上下文
+     */
+    once(names: string | string[], callback: (...args: any[]) => void, context?: any): () => this | undefined;
+    /**
+     * 解除事件
+     * @param  {string|[string]}  names    事件类型
+     * @param  {function}         callback 事件回调函数
+     *
+     * 如果 name 不传的话解除对应所有事件
+     * 如果 name, callback 不传的话解除所有name的所有事件
+     */
+    off(names?: string | string[], callback?: (...args: any[]) => void): this | undefined;
+    /**
+     * 触发事件
+     * @param  {string|[string]}    name      事件类型
+     * @param  {...any}             data      触发事件的数据
+     */
+    emit(name: string, ...data: any[]): boolean;
+}
+export {};

package/shared-utils/Subscribe.js

@@ -0,0 +1,210 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+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, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+/* eslint-disable  @typescript-eslint/no-explicit-any */
+var __EVENT__ = '__events__';
+/**
+ * 订阅类。
+ * 观察者模式（供前端使用），Node端推荐<a href="https://nodejs.org/api/events.html#events_class_eventemitter">EventEmitter</a>。
+ */
+
+var Subscribe = /*#__PURE__*/function () {
+  function Subscribe() {
+    _classCallCheck(this, Subscribe);
+
+    this[__EVENT__] = {};
+  }
+  /**
+   * 判断是否注册时事件
+   * @param  {string|[string]}  name     事件类型
+   */
+
+
+  _createClass(Subscribe, [{
+    key: "hasListener",
+    value: function hasListener(name) {
+      var events = this[__EVENT__];
+      return events && events[name] && events[name].length;
+    }
+    /**
+     * 注册事件
+     * @param  {string|[string]}  names    事件类型
+     * @param  {function}         callback 事件回调函数
+     * @param  {any}              context  事件回调函数调用的上下文
+     * @param  {boolean}          once     是否只执行一次
+     */
+
+  }, {
+    key: "on",
+    value: function on(names, callback, context) {
+      var _this = this;
+
+      var once = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+
+      var _iterator = _createForOfIteratorHelper([].concat(names)),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var name = _step.value;
+          if (!this[__EVENT__][name]) this[__EVENT__][name] = [];
+
+          this[__EVENT__][name].push([callback, context, once]);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+
+      return function () {
+        return _this.off(names, callback);
+      };
+    }
+    /**
+     * 注册事件(是否只执行一次)
+     * @param  {string|[string]}  names    事件类型
+     * @param  {function}         callback 事件回调函数
+     * @param  {any}              context  事件回调函数调用的上下文
+     */
+
+  }, {
+    key: "once",
+    value: function once(names, callback, context) {
+      return this.on(names, callback, context, true);
+    }
+    /**
+     * 解除事件
+     * @param  {string|[string]}  names    事件类型
+     * @param  {function}         callback 事件回调函数
+     *
+     * 如果 name 不传的话解除对应所有事件
+     * 如果 name, callback 不传的话解除所有name的所有事件
+     */
+
+  }, {
+    key: "off",
+    value: function off(names, callback) {
+      if (arguments.length === 0) {
+        this[__EVENT__] = {};
+        return;
+      }
+
+      var hasNames = function hasNames(names) {
+        return names;
+      };
+
+      if (hasNames(names)) {
+        var events = this[__EVENT__];
+
+        var _iterator2 = _createForOfIteratorHelper([].concat(names)),
+            _step2;
+
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var name = _step2.value;
+            if (events[name] === undefined) continue;
+
+            if (callback === undefined) {
+              events[name].length = 0;
+              continue;
+            }
+
+            events[name] = events[name].filter(function (one) {
+              return one[0] !== callback;
+            });
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+      }
+
+      return this;
+    }
+    /**
+     * 触发事件
+     * @param  {string|[string]}    name      事件类型
+     * @param  {...any}             data      触发事件的数据
+     */
+
+  }, {
+    key: "emit",
+    value: function emit(name) {
+      var canceled = false;
+      var event = this[__EVENT__][name] || [];
+
+      if (event.length === 0) {
+        console.warn(" \uD83D\uDC80 \"".concat(name, "\" \u27F6 Unregistered event. "));
+      }
+
+      for (var _len = arguments.length, data = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        data[_key - 1] = arguments[_key];
+      }
+
+      var _iterator3 = _createForOfIteratorHelper(event),
+          _step3;
+
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var one = _step3.value;
+
+          try {
+            var _one = _slicedToArray(one, 3),
+                callback = _one[0],
+                _one$ = _one[1],
+                context = _one$ === void 0 ? this : _one$,
+                _one$2 = _one[2],
+                once = _one$2 === void 0 ? false : _one$2;
+
+            var result = callback.apply(context, data);
+            if (once) this.off(name, callback);
+
+            if (result === false) {
+              // 如果回调的返回结果是false，则中断后续的调用链
+              canceled = true;
+              return canceled;
+            }
+          } catch (error) {
+            console.warn(error);
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+
+      return canceled;
+    }
+  }]);
+
+  return Subscribe;
+}();
+
+exports["default"] = Subscribe;

package/shared-utils/animationFrame/BetterTween.d.ts

@@ -0,0 +1,11 @@
+import TWEEN from '@tweenjs/tween.js';
+export declare class BetterTween<G> extends TWEEN.Tween<G> {
+    private disposeMethods;
+    private animationFrameDisposer?;
+    onDispose: (callback: () => void) => this;
+    play: () => this;
+    dispose: () => void;
+}
+export declare function tweenProgress(duration?: number, easing?: (amount: number) => number): BetterTween<{
+    progress: number;
+}>;