@realsee/dnalogel 0.1.0

package/shared-utils/math/planimetry.d.ts

@@ -0,0 +1,116 @@
+/**
+ * 平面几何相关数学函数
+ */
+/**
+ * 平面点坐标。
+ */
+export interface Point {
+    x: number;
+    y: number;
+}
+/**
+ * 检查两个点是否位置相同
+ * @param point1
+ * @param point2
+ * @return
+ */
+export declare function samePointAt(point1: Point, point2: Point): boolean;
+/**
+ * 计算两个点之间的位置
+ * @param  {point} point1
+ * @param  {point} point2
+ * @return {number}
+ */
+export declare function distance(point1: Point, point2: Point): number;
+/**
+ * 两个计算的斜率是否相同
+ * @param  {number} k1
+ * @param  {number} k2
+ * @return
+ */
+export declare function sameK(k1: number, k2: number): boolean;
+/**
+ * 获取两点之间的斜率
+ * @param  {point} point1
+ * @param  {point} point2
+ * @return {number}
+ */
+export declare function getK(point1: Point, point2: Point): number;
+/**
+ * 获取一点对于线段上最近的一点，
+ * 如果可以是过直线垂线的垂足，不行的话取线段的两端
+ * @param  {point} point1
+ * @param  {linePoints} linePoints
+ * @return {point}
+ */
+export declare function closestPointOnLine(point: Point, linePoints: Point[]): {
+    x: number;
+    y: number;
+};
+/**
+ * 点到线段的距离，
+ * 如果可以是过直线垂线的垂足的距离，不行的话取线段的两端的距离
+ * @param  {point} point1
+ * @param  {linePoints} linePoints
+ * @return {number}
+ */
+export declare function pointDistanceFromLine(point: Point, linePoints: Point[]): number;
+/**
+ * 做线段的距离一定值的平行线段
+ * @param  {number} distanceOfLine
+ * @param  {linePoints} linePoints
+ * @return {[linePoints, linePoints]}
+ */
+export declare function linesWithDistanceOfLine(distanceOfLine: number, linePoints: Point[]): {
+    x: number;
+    y: number;
+}[][];
+/**
+ * 做线段的距离一定值的平行线段 (如果线段是弧形的)
+ * @param  {number} distanceOfLine
+ * @param  {linePoints} linePoints
+ * @param  {number} 弧形定点到线段的距离
+ * @return {[linePoints, linePoints]}
+ */
+export declare function linesWithDistanceOfLineWithCurve(distanceOfLine: number, linePoints: Point[], curve: number): {
+    x: number;
+    y: number;
+}[][];
+/**
+ * 两条线段(包括延长线)的交点点
+ * @param  {linePoints} linePoints1
+ * @param  {linePoints} linePoints2
+ * @param   needIntersectionInLine 是否是延长线的相交
+ * @return {point || false}
+ */
+export declare function intersectionOfLine(linePoints1: Point[], linePoints2: Point[], needIntersectionInLine: boolean): false | Point;
+/**
+ * 是否点在线段上
+ * @param  {point} point
+ * @param  {linePoints} linePoints
+ * @return
+ */
+export declare function pointOnLine(point: Point, linePoints: Point[]): boolean;
+/**
+ * 让点按照另一个点为圆心，一定弧度的情况下转动得到下一个点
+ * @param  {point} point
+ * @param  {point} centerPoint
+ * @param  {number} rad
+ * @return {point}
+ */
+export declare function pointRotateByCenterPoint(point: Point, centerPoint: Point, rad: number): {
+    x: number;
+    y: number;
+};
+/**
+ * 获取一些点的中心点
+ * @param  {points} point
+ * @return {point}
+ */
+export declare function getCenterPointOfPoints(points: Point[]): {
+    x: number;
+    y: number;
+};
+export declare function isIntersect(linePoints1: Point[], linePoints2: Point[]): 1 | 0;
+export declare function getAreaSize(points: Point[]): number;
+export declare function getAreaSizeWithoutLine(points: Point[]): number;

package/shared-utils/math/planimetry.js

@@ -0,0 +1,342 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.closestPointOnLine = closestPointOnLine;
+exports.distance = distance;
+exports.getAreaSize = getAreaSize;
+exports.getAreaSizeWithoutLine = getAreaSizeWithoutLine;
+exports.getCenterPointOfPoints = getCenterPointOfPoints;
+exports.getK = getK;
+exports.intersectionOfLine = intersectionOfLine;
+exports.isIntersect = isIntersect;
+exports.linesWithDistanceOfLine = linesWithDistanceOfLine;
+exports.linesWithDistanceOfLineWithCurve = linesWithDistanceOfLineWithCurve;
+exports.pointDistanceFromLine = pointDistanceFromLine;
+exports.pointOnLine = pointOnLine;
+exports.pointRotateByCenterPoint = pointRotateByCenterPoint;
+exports.sameK = sameK;
+exports.samePointAt = samePointAt;
+
+/**
+ * 平面几何相关数学函数
+ */
+
+/**
+ * 平面点坐标。
+ */
+
+/**
+ * 检查两个点是否位置相同
+ * @param point1
+ * @param point2
+ * @return
+ */
+function samePointAt(point1, point2) {
+  return point1.x === point2.x && point1.y === point2.y;
+}
+/**
+ * 计算两个点之间的位置
+ * @param  {point} point1
+ * @param  {point} point2
+ * @return {number}
+ */
+
+
+function distance(point1, point2) {
+  return Math.sqrt(Math.pow(point2.x - point1.x, 2) + Math.pow(point2.y - point1.y, 2));
+}
+/**
+ * 两个计算的斜率是否相同
+ * @param  {number} k1
+ * @param  {number} k2
+ * @return
+ */
+
+
+function sameK(k1, k2) {
+  if (Math.abs(k1) === Infinity && Math.abs(k2) === Infinity) return true;
+  return Math.abs(k1 - k2) < 0.001;
+}
+/**
+ * 获取两点之间的斜率
+ * @param  {point} point1
+ * @param  {point} point2
+ * @return {number}
+ */
+
+
+function getK(point1, point2) {
+  return (point2.y - point1.y) / (point2.x - point1.x);
+}
+/**
+ * 获取一点对于线段上最近的一点，
+ * 如果可以是过直线垂线的垂足，不行的话取线段的两端
+ * @param  {point} point1
+ * @param  {linePoints} linePoints
+ * @return {point}
+ */
+
+
+function closestPointOnLine(point, linePoints) {
+  var tA = point.x - linePoints[0].x;
+  var tB = point.y - linePoints[0].y;
+  var tC = linePoints[1].x - linePoints[0].x;
+  var tD = linePoints[1].y - linePoints[0].y;
+  var tDot = tA * tC + tB * tD;
+  var tLenSq = tC * tC + tD * tD;
+  var tParam = tDot / tLenSq;
+  var tXx, tYy;
+
+  if (tParam < 0 || samePointAt(linePoints[0], linePoints[1])) {
+    tXx = linePoints[0].x;
+    tYy = linePoints[0].y;
+  } else if (tParam > 1) {
+    tXx = linePoints[1].x;
+    tYy = linePoints[1].y;
+  } else {
+    tXx = linePoints[0].x + tParam * tC;
+    tYy = linePoints[0].y + tParam * tD;
+  }
+
+  return {
+    x: tXx,
+    y: tYy
+  };
+}
+/**
+ * 点到线段的距离，
+ * 如果可以是过直线垂线的垂足的距离，不行的话取线段的两端的距离
+ * @param  {point} point1
+ * @param  {linePoints} linePoints
+ * @return {number}
+ */
+
+
+function pointDistanceFromLine(point, linePoints) {
+  var closestPoint = closestPointOnLine(point, linePoints);
+  return distance(point, closestPoint);
+}
+/**
+ * 做线段的距离一定值的平行线段
+ * @param  {number} distanceOfLine
+ * @param  {linePoints} linePoints
+ * @return {[linePoints, linePoints]}
+ */
+
+
+function linesWithDistanceOfLine(distanceOfLine, linePoints) {
+  var k = getK(linePoints[1], linePoints[0]);
+  var dx, dy;
+
+  if (Math.abs(k) === Infinity) {
+    dy = 0;
+    dx = distanceOfLine;
+  } else {
+    dy = Math.sqrt(distanceOfLine * distanceOfLine / (k * k + 1));
+    dx = dy / -(1 / k);
+  }
+
+  var result = [[{
+    x: linePoints[0].x - dx,
+    y: linePoints[0].y - dy
+  }, {
+    x: linePoints[1].x - dx,
+    y: linePoints[1].y - dy
+  }], [{
+    x: linePoints[0].x + dx,
+    y: linePoints[0].y + dy
+  }, {
+    x: linePoints[1].x + dx,
+    y: linePoints[1].y + dy
+  }]];
+
+  if (linePoints[1].x - linePoints[0].x < 0) {
+    return result;
+  } else if (linePoints[1].x - linePoints[0].x > 0) {
+    return result.reverse();
+  } else {
+    if (linePoints[1].y - linePoints[0].y < 0) {
+      return result.reverse();
+    } else {
+      return result;
+    }
+  }
+}
+/**
+ * 做线段的距离一定值的平行线段 (如果线段是弧形的)
+ * @param  {number} distanceOfLine
+ * @param  {linePoints} linePoints
+ * @param  {number} 弧形定点到线段的距离
+ * @return {[linePoints, linePoints]}
+ */
+
+
+function linesWithDistanceOfLineWithCurve(distanceOfLine, linePoints, curve) {
+  var centerPoint = getCenterPointOfPoints(linePoints);
+  var pHelfDistance = distance(linePoints[0], centerPoint);
+  var cDistance = Math.sqrt(curve * curve - pHelfDistance * pHelfDistance);
+  var cpoint = isNaN(cDistance) ? centerPoint : linesWithDistanceOfLine(cDistance, [centerPoint, linePoints[0]])[curve > 0 ? 0 : 1][0];
+  var dx1 = (linePoints[0].x - cpoint.x) / curve * distanceOfLine;
+  var dy1 = (linePoints[0].y - cpoint.y) / curve * distanceOfLine;
+  var dx2 = (linePoints[1].x - cpoint.x) / curve * distanceOfLine;
+  var dy2 = (linePoints[1].y - cpoint.y) / curve * distanceOfLine;
+  return [[{
+    x: linePoints[0].x - dx1,
+    y: linePoints[0].y - dy1
+  }, {
+    x: linePoints[1].x - dx2,
+    y: linePoints[1].y - dy2
+  }], [{
+    x: linePoints[0].x + dx1,
+    y: linePoints[0].y + dy1
+  }, {
+    x: linePoints[1].x + dx2,
+    y: linePoints[1].y + dy2
+  }]];
+}
+/**
+ * 两条线段(包括延长线)的交点点
+ * @param  {linePoints} linePoints1
+ * @param  {linePoints} linePoints2
+ * @param   needIntersectionInLine 是否是延长线的相交
+ * @return {point || false}
+ */
+
+
+function intersectionOfLine(linePoints1, linePoints2, needIntersectionInLine) {
+  var k1 = getK(linePoints1[1], linePoints1[0]);
+  var k2 = getK(linePoints2[1], linePoints2[0]);
+  if (isNaN(k1) || isNaN(k2)) return false;
+  if (sameK(k1, k2)) return false;
+  if (pointOnLine(linePoints1[0], linePoints2)) return linePoints1[0];
+  if (pointOnLine(linePoints1[1], linePoints2)) return linePoints1[1];
+  if (pointOnLine(linePoints2[0], linePoints1)) return linePoints2[0];
+  if (pointOnLine(linePoints2[1], linePoints1)) return linePoints2[1]; //needIntersectionInLine 是否焦点在线段内
+
+  if (needIntersectionInLine && !isIntersect(linePoints1, linePoints2)) return false;
+  var p1 = linePoints1[0];
+  var p2 = linePoints2[0];
+
+  if (Math.abs(k1) === Infinity) {
+    return {
+      x: p1.x,
+      y: linePoints2[1].y - (linePoints2[1].x - p1.x) * k2
+    };
+  }
+
+  if (Math.abs(k2) === Infinity) {
+    return {
+      x: p2.x,
+      y: linePoints1[1].y - (linePoints1[1].x - p2.x) * k1
+    };
+  }
+
+  var x = (p2.y - p1.y + k1 * p1.x - k2 * p2.x) / (k1 - k2);
+  var y = k1 * x - k1 * p1.x + p1.y;
+  return {
+    x: x,
+    y: y
+  };
+}
+/**
+ * 是否点在线段上
+ * @param  {point} point
+ * @param  {linePoints} linePoints
+ * @return
+ */
+
+
+function pointOnLine(point, linePoints) {
+  if (samePointAt(point, linePoints[0])) return true;
+  if (samePointAt(point, linePoints[1])) return true;
+  return true && (linePoints[0].x - point.x) * (point.x - linePoints[1].x) >= 0 && (linePoints[0].y - point.y) * (point.y - linePoints[1].y) >= 0 && sameK(getK(linePoints[0], point), getK(point, linePoints[1]));
+}
+/**
+ * 让点按照另一个点为圆心，一定弧度的情况下转动得到下一个点
+ * @param  {point} point
+ * @param  {point} centerPoint
+ * @param  {number} rad
+ * @return {point}
+ */
+
+
+function pointRotateByCenterPoint(point, centerPoint, rad) {
+  var r = distance(point, centerPoint);
+  var nextRad = Math.atan2(point.y - centerPoint.y, point.x - centerPoint.x);
+  nextRad -= rad;
+  return {
+    x: centerPoint.x + Math.cos(nextRad) * r,
+    y: centerPoint.y + Math.sin(nextRad) * r
+  };
+}
+/**
+ * 获取一些点的中心点
+ * @param  {points} point
+ * @return {point}
+ */
+
+
+function getCenterPointOfPoints(points) {
+  var minX = Infinity,
+      maxX = 0,
+      minY = Infinity,
+      maxY = 0;
+  points.forEach(function (point) {
+    minX = Math.min(minX, point.x);
+    maxX = Math.max(maxX, point.x);
+    minY = Math.min(minY, point.y);
+    maxY = Math.max(maxY, point.y);
+  });
+  return {
+    x: (minX + maxX) / 2,
+    y: (minY + maxY) / 2
+  };
+}
+/**
+ *  判断两条线段是否相交
+ */
+
+
+function multi(p1, p2, p0) {
+  return (p1.x - p0.x) * (p2.y - p0.y) - (p2.x - p0.x) * (p1.y - p0.y);
+}
+
+function isIntersect(linePoints1, linePoints2) {
+  if (Math.max(linePoints1[0].x, linePoints1[1].x) >= Math.min(linePoints2[0].x, linePoints2[1].x) && Math.max(linePoints2[0].x, linePoints2[1].x) >= Math.min(linePoints1[0].x, linePoints1[1].x) && Math.max(linePoints1[0].y, linePoints1[1].y) >= Math.min(linePoints2[0].y, linePoints2[1].y) && multi(linePoints2[0], linePoints1[1], linePoints1[0]) * multi(linePoints1[1], linePoints2[1], linePoints1[0]) > 0 && multi(linePoints1[0], linePoints2[1], linePoints2[0]) * multi(linePoints2[1], linePoints1[1], linePoints2[0]) > 0) return 1;
+  return 0;
+}
+/**
+ * 计算点按序围成区域的面就
+ * @param  {[point]} points
+ * @return {number}
+ */
+
+
+function cross(p1, p2) {
+  // 向量叉积
+  return p1.x * p2.y - p1.y * p2.x;
+}
+
+function getAreaSize(points) {
+  var ret = 0;
+  return (cross(points.reduce(function (pf, pn) {
+    ret += cross(pf, pn);
+    return pn;
+  }), points[0]) + ret) / 2;
+}
+
+function getAreaSizeWithoutLine(points) {
+  var ret = 0;
+  var r = (cross(points.reduce(function (pf, pn) {
+    ret += cross(pf, pn);
+    return pn;
+  }), points[0]) + ret) / 2;
+  var wall = 0;
+  var wr = (distance(points.reduce(function (pf, pn) {
+    wall += distance(pf, pn) * 250;
+    return pn;
+  }), points[0]) * 250 + wall) / 2;
+  return r - (wr - 250 * 1000) * (r > 0 ? 1 : -1);
+}

package/shared-utils/math/rad2Deg.d.ts

@@ -0,0 +1 @@
+export default function rad2Deg(rad: number): number;

package/shared-utils/math/rad2Deg.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = rad2Deg;
+
+function rad2Deg(rad) {
+  return rad * 180 / Math.PI;
+}

package/shared-utils/nearlyEqual.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 比较两个数字近似相等
+ * @param num1 数字1
+ * @param num2 数字2
+ * @param accuracy 精度：精确到小数点后几位，默认精确到 小数点后四位
+ */
+export default function nearlyEqual(num1: number, num2: number, accuracy?: number): boolean;

package/shared-utils/nearlyEqual.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = nearlyEqual;
+
+/**
+ * 比较两个数字近似相等
+ * @param num1 数字1
+ * @param num2 数字2
+ * @param accuracy 精度：精确到小数点后几位，默认精确到 小数点后四位
+ */
+function nearlyEqual(num1, num2) {
+  var accuracy = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 4;
+  return Math.floor(num1 * Math.pow(10, accuracy)) === Math.floor(num2 * Math.pow(10, accuracy));
+}

package/shared-utils/nextFrame.d.ts

@@ -0,0 +1 @@
+export declare function nextFrame(fn: () => void, delay?: number): void;

package/shared-utils/nextFrame.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.nextFrame = nextFrame;
+
+function nextFrame(fn) {
+  var delay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  if (delay <= 0) requestAnimationFrame(fn);else requestAnimationFrame(function () {
+    return nextFrame(fn, delay - 1);
+  });
+}

package/shared-utils/noop.d.ts

@@ -0,0 +1,5 @@
+declare function noop(): void;
+/**
+ * 空函数
+ */
+export default noop;

package/shared-utils/noop.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+function noop() {
+  return void 0;
+}
+/**
+ * 空函数
+ */
+
+
+var _default = noop;
+exports["default"] = _default;

package/shared-utils/object3d2LocalMatrix.d.ts

@@ -0,0 +1,12 @@
+import * as THREE from 'three';
+export declare const genRotationMatrix: (x: number, y: number, z: number) => THREE.Matrix4;
+declare const bject3d2LocalMatrix: (mesh: THREE.Object3D, { scale, rotation, position, }: {
+    scale: number;
+    rotation: number[];
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}) => THREE.Object3D;
+export default bject3d2LocalMatrix;

package/shared-utils/object3d2LocalMatrix.js

@@ -0,0 +1,73 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.genRotationMatrix = exports["default"] = void 0;
+
+var THREE = _interopRequireWildcard(require("three"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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; }
+
+var genRotationMatrix = function genRotationMatrix(x, y, z) {
+  var matrix = new THREE.Matrix4();
+  var euler = new THREE.Euler(x, y, z, 'YXZ');
+  matrix.makeRotationFromEuler(euler);
+  return matrix;
+};
+
+exports.genRotationMatrix = genRotationMatrix;
+
+var bject3d2LocalMatrix = function bject3d2LocalMatrix(mesh, _ref) {
+  var scale = _ref.scale,
+      rotation = _ref.rotation,
+      position = _ref.position;
+
+  if (scale) {
+    mesh.scale.set(scale, scale, scale);
+  }
+
+  if (rotation) {
+    var _rotation = _slicedToArray(rotation, 3),
+        x = _rotation[0],
+        y = _rotation[1],
+        z = _rotation[2];
+
+    if (x) {
+      mesh.applyMatrix4(genRotationMatrix(x, 0, 0));
+    }
+
+    if (y) {
+      mesh.applyMatrix4(genRotationMatrix(0, y, 0));
+    }
+
+    if (z) {
+      mesh.applyMatrix4(genRotationMatrix(0, 0, z));
+    }
+  }
+
+  if (position) {
+    mesh.position.set(position.x, position.y, position.z);
+  }
+
+  return mesh;
+};
+
+var _default = bject3d2LocalMatrix;
+exports["default"] = _default;

package/shared-utils/px2rem.d.ts

@@ -0,0 +1 @@
+export default function px2rem(_px: number | string, precision?: number): string;

package/shared-utils/px2rem.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = px2rem;
+
+function px2rem(_px) {
+  var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 16;
+  var px = Number(typeof _px === 'string' ? _px.replace(/px/g, '') : _px);
+  return (px / precision).toFixed(5) + 'rem';
+}

package/shared-utils/tap.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 把第一个参数传入第二个参数（函数）中并执行
+ * 一般用于执行函数后返回变量。
+ * @param {any} something
+ * @param {function} callback
+ * @return {any}
+ */
+export default function tap<T>(something: T, callback: (p: T) => any): T;

package/shared-utils/tap.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = tap;
+
+/**
+ * 把第一个参数传入第二个参数（函数）中并执行
+ * 一般用于执行函数后返回变量。
+ * @param {any} something
+ * @param {function} callback
+ * @return {any}
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function tap(something, callback) {
+  callback(something);
+  return something;
+}

package/shared-utils/three/centerPoint.d.ts

@@ -0,0 +1,2 @@
+import { Vector3 } from 'three';
+export default function centerPoint(point1: Vector3, point2: Vector3): Vector3;

package/shared-utils/three/centerPoint.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = centerPoint;
+
+var _three = require("three");
+
+function centerPoint(point1, point2) {
+  return new _three.Vector3((point1.x + point2.x) / 2, (point1.y + point2.y) / 2, (point1.z + point2.z) / 2);
+}