pubo-utils 1.0.149 → 1.0.157

package/es/level/index.js

@@ -1,24 +1,22 @@
-export var Level = /*#__PURE__*/function () {
-  function Level(props) {
-    this.config = void 0;
-    this.step = void 0;
-    this.config = props;
-    this.step = (this.config.max - this.config.min) / (this.config.count - 2);
-  }
-  var _proto = Level.prototype;
-  _proto.get = function get(value) {
-    if (value <= this.config.min) {
-      return 1;
+export class Level {
+    config;
+    step;
+    constructor(props) {
+        this.config = props;
+        this.step = (this.config.max - this.config.min) / (this.config.count - 2);
     }
-    if (value >= this.config.max) {
-      return this.config.count;
+    get(value) {
+        if (value <= this.config.min) {
+            return 1;
+        }
+        if (value >= this.config.max) {
+            return this.config.count;
+        }
+        for (let i = 2, v = this.config.min + this.step; v < this.config.max + this.step; v += this.step, i += 1) {
+            if (value < v) {
+                return i;
+            }
+        }
+        return this.config.count;
     }
-    for (var i = 2, v = this.config.min + this.step; v < this.config.max + this.step; v += this.step, i += 1) {
-      if (value < v) {
-        return i;
-      }
-    }
-    return this.config.count;
-  };
-  return Level;
-}();
+}

package/es/loop/index.js

@@ -6,130 +6,75 @@ import { sleep } from '../sleep';
  * @param {number} time - The time interval in milliseconds for the loop.
  * @return {Function} The stop function that can be used to stop the loop.
  */
-
-function _empty() {} /**
-                      * Waits for a boolean condition to be true, with optional timeouts for the check and the overall wait.
-                      *
-                      * @param {WaitForBool} bool - the boolean condition to wait for
-                      * @param {Object} options - optional parameters for checkTime and timeout
-                      * @param {number} options.checkTime - the time interval for checking the boolean condition (default is 100)
-                      * @param {number} options.timeout - the maximum time to wait for the boolean condition to be true
-                      * @return {Promise<any>} a promise that resolves when the boolean condition is true or rejects with 'timeout' if the timeout is reached
-                      */
-
-function _call(body, then, direct) {
-  if (direct) {
-    return then ? then(body()) : body();
-  }
-  try {
-    var result = Promise.resolve(body());
-    return then ? result.then(then) : result;
-  } catch (e) {
-    return Promise.reject(e);
-  }
-}
-function _callIgnored(body, direct) {
-  return _call(body, _empty, direct);
-}
-function _catch(body, recover) {
-  try {
-    var result = body();
-  } catch (e) {
-    return recover(e);
-  }
-  if (result && result.then) {
-    return result.then(void 0, recover);
-  }
-  return result;
-}
-function _await(value, then, direct) {
-  if (direct) {
-    return then ? then(value) : value;
-  }
-  if (!value || !value.then) {
-    value = Promise.resolve(value);
-  }
-  return then ? value.then(then) : value;
-}
-function _continue(value, then) {
-  return value && value.then ? value.then(then) : then(value);
-}
-function _async(f) {
-  return function () {
-    for (var args = [], i = 0; i < arguments.length; i++) {
-      args[i] = arguments[i];
-    }
-    try {
-      return Promise.resolve(f.apply(this, args));
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  };
-}
-export var loop = function loop(cb, time) {
-  var onOff = true;
-  var stop = function stop() {
-    onOff = false;
-  };
-  var fn = _async(function () {
-    return _continue(_catch(function () {
-      return _callIgnored(cb);
-    }, function (err) {
-      console.log(err);
-    }), function () {
-      return _await(sleep(time), function () {
-        if (onOff) {
-          fn();
-        } else {
-          fn = null;
-          cb = null;
-          stop = null;
-          onOff = null;
-          time = null;
+export const loop = (cb, time) => {
+    let onOff = true;
+    let stop = () => {
+        onOff = false;
+    };
+    let fn = async () => {
+        try {
+            await cb();
         }
-      });
-    });
-  });
-  fn();
-  return stop;
-};
-export var waitFor = function waitFor(bool, _temp) {
-  var _ref = _temp === void 0 ? {} : _temp,
-    checkTime = _ref.checkTime,
-    timeout = _ref.timeout;
-  return new Promise(function (resolve, reject) {
-    var _timeout;
-    var stop = loop(function () {
-      return _call(bool, function (res) {
-        if (res) {
-          if (typeof stop === 'function') {
-            stop();
-          }
-          if (_timeout) {
-            clearTimeout(_timeout);
-            _timeout = null;
-          }
-          resolve(res);
-          stop = null;
-          bool = null;
-          resolve = null;
+        catch (err) {
+            console.log(err);
         }
-      });
-    }, checkTime || 100);
-    if (timeout) {
-      _timeout = setTimeout(function () {
-        if (typeof stop === 'function') {
-          stop();
+        await sleep(time);
+        if (onOff) {
+            fn();
         }
-        if (_timeout) {
-          clearTimeout(_timeout);
-          _timeout = null;
+        else {
+            fn = null;
+            cb = null;
+            stop = null;
+            onOff = null;
+            time = null;
         }
-        reject('timeout');
-        reject = null;
-        stop = null;
-        bool = null;
-      }, timeout);
-    }
-  });
-};
+    };
+    fn();
+    return stop;
+};
+/**
+ * Waits for a boolean condition to be true, with optional timeouts for the check and the overall wait.
+ *
+ * @param {WaitForBool} bool - the boolean condition to wait for
+ * @param {Object} options - optional parameters for checkTime and timeout
+ * @param {number} options.checkTime - the time interval for checking the boolean condition (default is 100)
+ * @param {number} options.timeout - the maximum time to wait for the boolean condition to be true
+ * @return {Promise<any>} a promise that resolves when the boolean condition is true or rejects with 'timeout' if the timeout is reached
+ */
+export const waitFor = (bool, { checkTime, timeout } = {}) => {
+    return new Promise((resolve, reject) => {
+        let _timeout;
+        let stop = loop(async () => {
+            const res = await bool();
+            if (res) {
+                if (typeof stop === 'function') {
+                    stop();
+                }
+                if (_timeout) {
+                    clearTimeout(_timeout);
+                    _timeout = null;
+                }
+                resolve(res);
+                stop = null;
+                bool = null;
+                resolve = null;
+            }
+        }, checkTime || 100);
+        if (timeout) {
+            _timeout = setTimeout(() => {
+                if (typeof stop === 'function') {
+                    stop();
+                }
+                if (_timeout) {
+                    clearTimeout(_timeout);
+                    _timeout = null;
+                }
+                reject('timeout');
+                reject = null;
+                stop = null;
+                bool = null;
+            }, timeout);
+        }
+    });
+};

package/es/math/geometry.js

@@ -1,124 +1,95 @@
-function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
-function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate 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; }
 // 获取两点的距离
-export var getDistance = function getDistance(a, b) {
-  return Math.sqrt(Math.pow(a.x - b.x, 2) + Math.pow(a.y - b.y, 2));
+export const getDistance = (a, b) => {
+    return Math.sqrt(Math.pow(a.x - b.x, 2) + Math.pow(a.y - b.y, 2));
 };
 // 弧度转角度
-export var degrees = function degrees(rad) {
-  return rad * 180 / Math.PI;
+export const degrees = (rad) => {
+    return (rad * 180) / Math.PI;
 };
 // 角度转弧度
-export var radians = function radians(deg) {
-  return deg * Math.PI / 180;
+export const radians = (deg) => {
+    return (deg * Math.PI) / 180;
 };
 // 获取三角形角度
-export var getAngle = function getAngle(_ref) {
-  var w = _ref.w,
-    h = _ref.h;
-  return degrees(Math.atan2(h, w));
+export const getAngle = ({ w, h }) => {
+    return degrees(Math.atan2(h, w));
 };
 // 关键点过滤
-export function filterKeyPoints(list, len) {
-  if (len === void 0) {
-    len = 0.5;
-  }
-  if (list.length < 3 || len <= 0) {
-    return list;
-  }
-  var last;
-  return list.filter(function (item, i) {
-    if (i > 0 && getDistance(last, item) < len) {
-      return false;
+export function filterKeyPoints(list, len = 0.5) {
+    if (list.length < 3 || len <= 0) {
+        return list;
     }
-    last = list[i];
-    return true;
-  });
+    let last;
+    return list.filter((item, i) => {
+        if (i > 0 && getDistance(last, item) < len) {
+            return false;
+        }
+        last = list[i];
+        return true;
+    });
 }
 // 获取中心点坐标
 export function getCenter(list) {
-  var tmp = [0, 0];
-  for (var _iterator = _createForOfIteratorHelperLoose(list), _step; !(_step = _iterator()).done;) {
-    var item = _step.value;
-    if (Array.isArray(item)) {
-      tmp[0] += item[0];
-      tmp[1] += item[1];
-    } else {
-      tmp[0] += item.x;
-      tmp[1] += item.y;
+    const tmp = [0, 0];
+    for (const item of list) {
+        if (Array.isArray(item)) {
+            tmp[0] += item[0];
+            tmp[1] += item[1];
+        }
+        else {
+            tmp[0] += item.x;
+            tmp[1] += item.y;
+        }
     }
-  }
-  return {
-    x: tmp[0] / list.length,
-    y: tmp[1] / list.length
-  };
+    return { x: tmp[0] / list.length, y: tmp[1] / list.length };
 }
 // 2D旋转
 export function getRotate(data, theta) {
-  var x = Math.cos(theta) * data[0] - Math.sin(theta) * data[1];
-  var y = Math.sin(theta) * data[0] + Math.cos(theta) * data[1];
-  return [x, y];
+    const x = Math.cos(theta) * data[0] - Math.sin(theta) * data[1];
+    const y = Math.sin(theta) * data[0] + Math.cos(theta) * data[1];
+    return [x, y];
 }
 // 获取A点到B点的方向角
-export var getPositionTheta = function getPositionTheta(a, b) {
-  var vector = {
-    x: b.x - a.x,
-    y: b.y - a.y
-  };
-  return Math.atan2(vector.y, vector.x);
+export const getPositionTheta = (a, b) => {
+    const vector = { x: b.x - a.x, y: b.y - a.y };
+    return Math.atan2(vector.y, vector.x);
 };
 // 获取距离和方向最佳的位置点
-export var getBestPointIndex = function getBestPointIndex(points, pose) {
-  if (points.length < 2) {
-    return 0;
-  }
-  var temp = [];
-  var minDistance = Infinity;
-  var index = 0;
-  for (var _iterator2 = _createForOfIteratorHelperLoose(points), _step2; !(_step2 = _iterator2()).done;) {
-    var item = _step2.value;
-    var distance = getDistance(item, pose);
-    var theta = getPositionTheta(pose, item) - pose.theta;
-    if (minDistance > distance) {
-      minDistance = distance;
+export const getBestPointIndex = (points, pose) => {
+    if (points.length < 2) {
+        return 0;
     }
-    temp.push(_extends({}, item, {
-      index: index,
-      distance: distance,
-      theta: theta
-    }));
-    index += 1;
-  }
-  var results = temp.filter(function (item) {
-    return item.distance - minDistance < 0.1;
-  }).sort(function (a, b) {
-    return a.theta - b.theta;
-  });
-  return results[0].index;
+    const temp = [];
+    let minDistance = Infinity;
+    let index = 0;
+    for (const item of points) {
+        const distance = getDistance(item, pose);
+        const theta = getPositionTheta(pose, item) - pose.theta;
+        if (minDistance > distance) {
+            minDistance = distance;
+        }
+        temp.push({ ...item, index, distance, theta });
+        index += 1;
+    }
+    const results = temp
+        .filter((item) => item.distance - minDistance < 0.1)
+        .sort((a, b) => a.theta - b.theta);
+    return results[0].index;
 };
 // 按照距离和方向排序
-export var orderByDistance = function orderByDistance(points, pose) {
-  if (pose === void 0) {
-    pose = {
-      x: 0,
-      y: 0,
-      theta: 0
-    };
-  }
-  var current = pose;
-  var results = [];
-  var arr = [].concat(points);
-  while (arr.length > 0) {
-    var index = getBestPointIndex(arr, current);
-    results.push(arr[index]);
-    current = arr[index];
-    arr.splice(index, 1);
-  }
-  return results;
+export const orderByDistance = (points, pose = { x: 0, y: 0, theta: 0 }) => {
+    let current = pose;
+    const results = [];
+    const arr = [...points];
+    while (arr.length > 0) {
+        const index = getBestPointIndex(arr, current);
+        results.push(arr[index]);
+        current = arr[index];
+        arr.splice(index, 1);
+    }
+    return results;
 };
 // 获取向量a到向量b的夹角
-export var getVectorTheta = function getVectorTheta(a, b) {
-  return Math.atan2(b.y, b.x) - Math.atan2(a.y, a.x);
-};
+export const getVectorTheta = (a, b) => {
+    return Math.atan2(b.y, b.x) - Math.atan2(a.y, a.x);
+};

package/es/promise/index.js

@@ -1,24 +1,17 @@
 // 回调函数转异步函数
-export var callbackToPromise = function callbackToPromise(fn) {
-  return function () {
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-    return new Promise(function (resolve, reject) {
-      fn.apply(void 0, args.concat([function (err) {
-        if (err) {
-          reject(err);
-        }
-        for (var _len2 = arguments.length, rest = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-          rest[_key2 - 1] = arguments[_key2];
-        }
-        if (rest.length < 2) {
-          resolve(rest[0]);
-        } else {
-          resolve([].concat(rest));
-        }
-      }]));
-      fn = null;
+export const callbackToPromise = (fn) => {
+    return (...args) => new Promise((resolve, reject) => {
+        fn(...args, (err, ...rest) => {
+            if (err) {
+                reject(err);
+            }
+            if (rest.length < 2) {
+                resolve(rest[0]);
+            }
+            else {
+                resolve([...rest]);
+            }
+        });
+        fn = null;
     });
-  };
-};
+};

package/es/queue/index.js

@@ -1,122 +1,43 @@
-function _call(body, then, direct) {
-  if (direct) {
-    return then ? then(body()) : body();
-  }
-  try {
-    var result = Promise.resolve(body());
-    return then ? result.then(then) : result;
-  } catch (e) {
-    return Promise.reject(e);
-  }
-}
-function _catch(body, recover) {
-  try {
-    var result = body();
-  } catch (e) {
-    return recover(e);
-  }
-  if (result && result.then) {
-    return result.then(void 0, recover);
-  }
-  return result;
-}
-function _continue(value, then) {
-  return value && value.then ? value.then(then) : then(value);
-}
-function _await(value, then, direct) {
-  if (direct) {
-    return then ? then(value) : value;
-  }
-  if (!value || !value.then) {
-    value = Promise.resolve(value);
-  }
-  return then ? value.then(then) : value;
-}
-function _empty() {}
-function _awaitIgnored(value, direct) {
-  if (!direct) {
-    return value && value.then ? value.then(_empty) : Promise.resolve();
-  }
-}
-function _invoke(body, then) {
-  var result = body();
-  if (result && result.then) {
-    return result.then(then);
-  }
-  return then(result);
-}
-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 _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-export var SyncQueue = /*#__PURE__*/function () {
-  function SyncQueue() {
-    this.cache = [];
-    this.running = false;
-    this.len = 0;
-  }
-  var _proto = SyncQueue.prototype;
-  _proto._run = function _run(_ref) {
-    var fn = _ref.fn,
-      promise = _ref.promise;
-    try {
-      return _await(_continue(_catch(function () {
-        return _call(fn, function (res) {
-          promise.resolve(res);
-        });
-      }, function (err) {
-        promise.reject(err);
-      }), function () {
+export class SyncQueue {
+    cache = [];
+    running = false;
+    len = 0;
+    async _run({ fn, promise }) {
+        try {
+            const res = await fn();
+            promise.resolve(res);
+        }
+        catch (err) {
+            promise.reject(err);
+        }
         fn = null;
         promise = null;
-      }));
-    } catch (e) {
-      return Promise.reject(e);
     }
-  };
-  _proto.run = function run() {
-    try {
-      var _this = this;
-      if (_this.cache.length < 1) {
-        _this.running = false;
-        return _await();
-      } else {
-        _this.running = true;
-      }
-      var item = _this.cache.shift();
-      _this.len -= 1;
-      return _await(_invoke(function () {
+    async run() {
+        if (this.cache.length < 1) {
+            this.running = false;
+            return;
+        }
+        else {
+            this.running = true;
+        }
+        const item = this.cache.shift();
+        this.len -= 1;
         if (typeof item.fn === 'function') {
-          return _awaitIgnored(_this._run(item));
+            await this._run(item);
         }
-      }, function () {
-        _this.run();
-      }));
-    } catch (e) {
-      return Promise.reject(e);
+        this.run();
     }
-  };
-  _proto.push = function push(fn) {
-    var _this2 = this;
-    this.len += 1;
-    return new Promise(function (resolve, reject) {
-      _this2.cache.push({
-        fn: fn,
-        promise: {
-          resolve: resolve,
-          reject: reject
-        }
-      });
-      if (!_this2.running) {
-        _this2.run();
-      }
-    });
-  };
-  _createClass(SyncQueue, [{
-    key: "length",
-    get: function get() {
-      return this.len;
+    push(fn) {
+        this.len += 1;
+        return new Promise((resolve, reject) => {
+            this.cache.push({ fn, promise: { resolve, reject } });
+            if (!this.running) {
+                this.run();
+            }
+        });
+    }
+    get length() {
+        return this.len;
     }
-  }]);
-  return SyncQueue;
-}();
+}