@zykj2024/much-library 1.1.7-beta.3 → 1.1.7-beta.4

package/dist/esm/McUpload/tools/uploadTools.js

@@ -0,0 +1,56 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+// web workers 如果说是cpu密集型任务，一般开启不超过10个，低于cpu2核，给用户的其他程序留出空间，
+// 如果是io密集型任务，一般开启2-4个或低于cpu核心数一半，因为io密集型任务会大量阻塞，开启太多反而会降低性能
+
+import { isNumber } from "./materialVerification";
+
+// 统计方法执行时长
+export function measureExecutionTime(fn) {
+  return /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+    var start,
+      result,
+      end,
+      duration,
+      _args = arguments;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          start = Date.now();
+          _context.prev = 1;
+          _context.next = 4;
+          return fn.apply(void 0, _args);
+        case 4:
+          result = _context.sent;
+          _context.next = 10;
+          break;
+        case 7:
+          _context.prev = 7;
+          _context.t0 = _context["catch"](1);
+          // 如果函数抛出错误，将其捕获并存储在 result 中
+          result = _context.t0;
+        case 10:
+          end = Date.now();
+          duration = end - start; // 转换为毫秒
+          // 返回执行时间和函数结果
+          return _context.abrupt("return", {
+            duration: duration,
+            result: result
+          });
+        case 13:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[1, 7]]);
+  }));
+}
+export var transformNumber = function transformNumber(num) {
+  if (!isNumber(num)) {
+    var tempNum = Number(num);
+    if (isNumber(tempNum)) {
+      return tempNum;
+    }
+    return 0;
+  }
+  return num;
+};

package/dist/esm/Utils/index.d.ts

@@ -0,0 +1,8 @@
+/** 工具方法 */
+export { default as debounce } from 'lodash/debounce';
+export { default as isEmpty } from 'lodash/isEmpty';
+export { default as isNil } from 'lodash/isNil';
+export { default as throttle } from 'lodash/throttle';
+export { default as PriorityQueueTask } from './lib/Queue/PriorityQueue';
+export { default as TaskQueue } from './lib/Queue/TaskQueue';
+export { default as copyToClipboard } from './lib/copyToClipboard';

package/dist/esm/Utils/index.js

@@ -0,0 +1,9 @@
+/** 工具方法 */
+
+export { default as debounce } from 'lodash/debounce';
+export { default as isEmpty } from 'lodash/isEmpty';
+export { default as isNil } from 'lodash/isNil';
+export { default as throttle } from 'lodash/throttle';
+export { default as PriorityQueueTask } from "./lib/Queue/PriorityQueue";
+export { default as TaskQueue } from "./lib/Queue/TaskQueue";
+export { default as copyToClipboard } from "./lib/copyToClipboard";

package/dist/esm/Utils/lib/Queue/PriorityQueue.d.ts

@@ -0,0 +1,21 @@
+import { BinaryHeap } from './tools/BinaryHeap';
+import { BaseTaskQueue, Task, TaskConfig } from './types/baseTaskQueue';
+export interface PriorityQueueTask extends Task {
+    priority: number;
+}
+declare class PriorityQueue extends BaseTaskQueue<BinaryHeap<TaskConfig>, Task> {
+    queue: BinaryHeap<TaskConfig>;
+    private runningTasks;
+    private pausedTasks;
+    private isPaused;
+    private maxConcurrency;
+    [key: string | symbol]: any;
+    constructor(maxConcurrency?: number, tasks?: PriorityQueueTask[]);
+    addTask(taskConfig: PriorityQueueTask | PriorityQueueTask[]): void;
+    runTasks(): void;
+    pauseTask(taskFilter: (task: TaskConfig) => boolean): void;
+    resumeTask(taskFilter: (task: Task) => boolean): void;
+    cancelTask(taskFilter: (task: Task) => boolean): void;
+    getTaskCount(type: 'all' | 'running' | 'notRunning'): number;
+}
+export default PriorityQueue;

package/dist/esm/Utils/lib/Queue/PriorityQueue.js

@@ -0,0 +1,197 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { BinaryHeap } from "./tools/BinaryHeap";
+import { asyncWrap } from "./tools/publicDependencyMethod";
+import { BaseTaskQueue } from "./types/baseTaskQueue";
+var PriorityQueue = /*#__PURE__*/function (_BaseTaskQueue) {
+  _inherits(PriorityQueue, _BaseTaskQueue);
+  var _super = _createSuper(PriorityQueue);
+  function PriorityQueue() {
+    var _this;
+    var maxConcurrency = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+    var tasks = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    _classCallCheck(this, PriorityQueue);
+    _this = _super.call(this);
+    _defineProperty(_assertThisInitialized(_this), "queue", void 0);
+    // 正在执行的任务队列
+    _defineProperty(_assertThisInitialized(_this), "runningTasks", []);
+    // 运行中被暂停的任务队列
+    _defineProperty(_assertThisInitialized(_this), "pausedTasks", []);
+    // 是否暂停任务
+    _defineProperty(_assertThisInitialized(_this), "isPaused", false);
+    // 最大并发数
+    _defineProperty(_assertThisInitialized(_this), "maxConcurrency", 1);
+    _this.queue = new BinaryHeap(function (a, b) {
+      return a.priority - b.priority;
+    });
+    tasks === null || tasks === void 0 || tasks.map(function (item) {
+      return _objectSpread(_objectSpread({}, item), {}, {
+        task: asyncWrap(item.task),
+        isPaused: _this.isPaused
+      });
+    }).forEach(function (task) {
+      _this.queue.insert(task);
+    });
+    _this.maxConcurrency = maxConcurrency;
+    return _this;
+  }
+  _createClass(PriorityQueue, [{
+    key: "addTask",
+    value: function addTask(taskConfig) {
+      var _this2 = this;
+      if (Array.isArray(taskConfig)) {
+        taskConfig.forEach(function (item) {
+          var _this2$queue;
+          (_this2$queue = _this2.queue) === null || _this2$queue === void 0 || _this2$queue.insert(_objectSpread(_objectSpread({}, item), {}, {
+            task: asyncWrap(item.task),
+            isPaused: _this2.isPaused
+          }));
+        });
+      } else {
+        var _this$queue;
+        (_this$queue = this.queue) === null || _this$queue === void 0 || _this$queue.insert(_objectSpread(_objectSpread({}, taskConfig), {}, {
+          task: asyncWrap(taskConfig.task),
+          isPaused: this.isPaused
+        }));
+      }
+      this.runTasks();
+    }
+  }, {
+    key: "runTasks",
+    value: function runTasks() {
+      var _this3 = this;
+      if (this.isPaused || this.runningTasks.length >= this.maxConcurrency || this.queue.size() === 0 && this.pausedTasks.length === 0) {
+        return;
+      }
+      var _loop = function _loop() {
+        // 查看被暂停的任务队列中有没有可以执行的
+        var pasuedIndex = _this3.pausedTasks.findIndex(function (task) {
+          return !task.isPaused;
+        });
+        if (pasuedIndex !== -1) {
+          var _pasuedTask$resume;
+          var pasuedTask = _this3.pausedTasks[pasuedIndex];
+          pasuedTask === null || pasuedTask === void 0 || (_pasuedTask$resume = pasuedTask.resume) === null || _pasuedTask$resume === void 0 || _pasuedTask$resume.call(pasuedTask);
+          _this3.pausedTasks = _this3.pausedTasks.filter(function (task) {
+            return task.id !== pasuedTask.id;
+          });
+          _this3.runningTasks.push(pasuedTask);
+        } else {
+          var _task = _this3.queue.find(function (task) {
+            return !task.isPaused;
+          });
+          if (_task) {
+            _this3.queue = _this3.queue.filter(function (t) {
+              return t.id !== _task.id;
+            });
+            _this3.runningTasks.push(_task);
+            _task.task().then(function (res) {
+              var _task$onFinished;
+              _task === null || _task === void 0 || (_task$onFinished = _task.onFinished) === null || _task$onFinished === void 0 || _task$onFinished.call(_task, [null, res]);
+            }).catch(function (err) {
+              var _task$onFinished2;
+              _task === null || _task === void 0 || (_task$onFinished2 = _task.onFinished) === null || _task$onFinished2 === void 0 || _task$onFinished2.call(_task, [err, null]);
+            }).finally(function () {
+              _this3.runningTasks = _this3.runningTasks.filter(function (t) {
+                return t.id !== _task.id;
+              });
+              _this3.runTasks();
+              _task.isPaused = false;
+            });
+          }
+        }
+      };
+      while ((this.queue.size() > 0 && (_this$queue2 = this.queue) !== null && _this$queue2 !== void 0 && _this$queue2.some(function (task) {
+        return !task.isPaused;
+      }) || this.pausedTasks.length > 0 && (_this$pausedTasks = this.pausedTasks) !== null && _this$pausedTasks !== void 0 && _this$pausedTasks.some(function (task) {
+        return !task.isPaused;
+      })) && this.runningTasks.length < this.maxConcurrency && !this.isPaused) {
+        var _this$queue2, _this$pausedTasks;
+        _loop();
+      }
+    }
+    // 暂停所有任务
+
+    // 暂停指定任务
+  }, {
+    key: "pauseTask",
+    value: function pauseTask(taskFilter) {
+      this.queue.forEach(function (task) {
+        if (taskFilter(task)) {
+          task.isPaused = true;
+        }
+      });
+      this.runningTasks.forEach(function (task) {
+        if (taskFilter(task)) {
+          var _task$pause;
+          task === null || task === void 0 || (_task$pause = task.pause) === null || _task$pause === void 0 || _task$pause.call(task);
+          task.isPaused = true;
+        }
+      });
+      this.pausedTasks = this.pausedTasks.concat(this.runningTasks.filter(taskFilter));
+      this.runningTasks = this.runningTasks.filter(function (task) {
+        return !taskFilter(task);
+      });
+      this.runTasks();
+    }
+
+    // 恢复指定任务执行
+  }, {
+    key: "resumeTask",
+    value: function resumeTask(taskFilter) {
+      this.queue.forEach(function (task) {
+        if (taskFilter(task)) {
+          task.isPaused = false;
+        }
+      });
+      this.pausedTasks.forEach(function (task) {
+        if (taskFilter(task)) {
+          // task?.resume?.()
+          task.isPaused = false;
+        }
+      });
+      this.runTasks();
+    }
+
+    // 取消任务
+  }, {
+    key: "cancelTask",
+    value: function cancelTask(taskFilter) {
+      // 任务还没有执行，从队列中移除
+      this.queue = this.queue.filter(taskFilter);
+      // 任务正在执行，取消执行，从正在执行的任务队列中移除
+      this.runningTasks.forEach(function (task) {
+        if (taskFilter(task)) {
+          var _task$cancel;
+          task === null || task === void 0 || (_task$cancel = task.cancel) === null || _task$cancel === void 0 || _task$cancel.call(task);
+        }
+      });
+      this.runningTasks = this.runningTasks.filter(taskFilter);
+      this.pausedTasks = this.pausedTasks.filter(taskFilter);
+      this.runTasks();
+    }
+
+    // 获取当前正在执行的任务数数量
+  }, {
+    key: "getTaskCount",
+    value: function getTaskCount(type) {
+      switch (type) {
+        case 'all':
+          return this.queue.size() + this.runningTasks.length;
+        case 'running':
+          return this.runningTasks.length;
+        case 'notRunning':
+          return this.queue.size();
+        default:
+          return 0;
+      }
+    }
+  }]);
+  return PriorityQueue;
+}(BaseTaskQueue);
+export default PriorityQueue;

package/dist/esm/Utils/lib/Queue/TaskQueue.d.ts

@@ -0,0 +1,17 @@
+import { BaseTaskQueue, Task, TaskConfig } from './types/baseTaskQueue';
+declare class TaskQueue extends BaseTaskQueue<Task[], Task> {
+    queue: TaskConfig[];
+    private runningTasks;
+    private pausedTasks;
+    private isPaused;
+    private maxConcurrency;
+    [key: string | symbol]: any;
+    constructor(maxConcurrency?: number, tasks?: Task[]);
+    addTask(taskConfig: Task | Task[]): void;
+    pauseTask(taskFilter: (task: Task) => boolean): void;
+    resumeTask(taskFilter: (task: Task) => boolean): void;
+    cancelTask(taskFilter: (task: Task) => boolean): void;
+    runTasks(): void;
+    getTaskCount(type: 'all' | 'running' | 'notRunning'): number;
+}
+export default TaskQueue;

package/dist/esm/Utils/lib/Queue/TaskQueue.js

@@ -0,0 +1,199 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+// 任务队列（顺序队列）
+import { asyncWrap } from "./tools/publicDependencyMethod";
+import { BaseTaskQueue } from "./types/baseTaskQueue";
+var TaskQueue = /*#__PURE__*/function (_BaseTaskQueue) {
+  _inherits(TaskQueue, _BaseTaskQueue);
+  var _super = _createSuper(TaskQueue);
+  function TaskQueue() {
+    var _this;
+    var maxConcurrency = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+    var tasks = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    _classCallCheck(this, TaskQueue);
+    _this = _super.call(this);
+    // 任务队列
+    _defineProperty(_assertThisInitialized(_this), "queue", []);
+    // 正在执行的任务队列
+    _defineProperty(_assertThisInitialized(_this), "runningTasks", []);
+    // 运行中被暂停的任务队列
+    _defineProperty(_assertThisInitialized(_this), "pausedTasks", []);
+    // 是否暂停任务
+    _defineProperty(_assertThisInitialized(_this), "isPaused", false);
+    // 最大并发数
+    _defineProperty(_assertThisInitialized(_this), "maxConcurrency", 1);
+    _this.maxConcurrency = maxConcurrency;
+    _this.queue = tasks === null || tasks === void 0 ? void 0 : tasks.map(function (item) {
+      return _objectSpread(_objectSpread({}, item), {}, {
+        task: asyncWrap(item.task),
+        isPaused: _this.isPaused
+      });
+    });
+    return _this;
+  }
+
+  // 添加任务到队列
+  _createClass(TaskQueue, [{
+    key: "addTask",
+    value: function addTask(taskConfig) {
+      var _this2 = this;
+      if (Array.isArray(taskConfig)) {
+        taskConfig.forEach(function (taskItem) {
+          _this2.queue.push(_objectSpread(_objectSpread({}, taskItem), {}, {
+            task: asyncWrap(taskItem.task),
+            isPaused: _this2.isPaused
+          }));
+        });
+      } else {
+        this.queue.push(_objectSpread(_objectSpread({}, taskConfig), {}, {
+          task: asyncWrap(taskConfig.task),
+          isPaused: this.isPaused
+        }));
+      }
+      this.runTasks();
+    }
+
+    // 暂停指定任务
+  }, {
+    key: "pauseTask",
+    value: function pauseTask(taskFilter) {
+      var _this3 = this;
+      this.queue.forEach(function (task) {
+        if (taskFilter(task)) {
+          task.isPaused = true;
+        }
+      });
+      this.runningTasks.forEach(function (task) {
+        if (taskFilter(task)) {
+          var _task$pause;
+          task === null || task === void 0 || (_task$pause = task.pause) === null || _task$pause === void 0 || _task$pause.call(task);
+          task.isPaused = true;
+          _this3.pausedTasks.push(task);
+        }
+      });
+      this.runningTasks = this.runningTasks.filter(function (task) {
+        return !taskFilter(task);
+      });
+      this.runTasks();
+    }
+
+    // 恢复任务
+  }, {
+    key: "resumeTask",
+    value: function resumeTask(taskFilter) {
+      this.queue.forEach(function (task) {
+        if (taskFilter(task)) {
+          task.isPaused = false;
+        }
+      });
+      this.pausedTasks.forEach(function (task) {
+        if (taskFilter(task)) {
+          //  变为可执行任务等待任务队列取出执行
+          task.isPaused = false;
+        }
+      });
+      this.runTasks();
+    }
+
+    // 取消任务
+  }, {
+    key: "cancelTask",
+    value: function cancelTask(taskFilter) {
+      this.queue = this.queue.filter(function (task) {
+        return !taskFilter(task);
+      });
+      var cancelTasks = this.runningTasks.filter(taskFilter);
+      cancelTasks === null || cancelTasks === void 0 || cancelTasks.forEach(function (task) {
+        if (taskFilter(task)) {
+          var _task$cancel;
+          task === null || task === void 0 || (_task$cancel = task.cancel) === null || _task$cancel === void 0 || _task$cancel.call(task);
+        }
+      });
+      this.runningTasks = this.runningTasks.filter(function (task) {
+        return !taskFilter(task);
+      });
+      // 从暂停队列中移除
+      this.pausedTasks = this.pausedTasks.filter(function (task) {
+        return !taskFilter(task);
+      });
+      this.runTasks();
+    }
+
+    // 运行任务
+  }, {
+    key: "runTasks",
+    value: function runTasks() {
+      var _this4 = this;
+      if (this.isPaused || this.runningTasks.length >= this.maxConcurrency || this.queue.length === 0 && this.pausedTasks.length === 0) {
+        return;
+      }
+      var _loop = function _loop() {
+        // 查看暂停的任务队列中有没有被激活的任务
+        var pauseIndex = _this4.pausedTasks.findIndex(function (task) {
+          return !task.isPaused;
+        });
+        if (pauseIndex > -1) {
+          var _task$resume;
+          var _task = _this4.pausedTasks[pauseIndex];
+          _this4.pausedTasks = _this4.pausedTasks.slice(0, pauseIndex).concat(_this4.pausedTasks.slice(pauseIndex + 1));
+          // 恢复执行
+          _task === null || _task === void 0 || (_task$resume = _task.resume) === null || _task$resume === void 0 || _task$resume.call(_task);
+          _this4.runningTasks.push(_task);
+        } else {
+          var indx = _this4.queue.findIndex(function (task) {
+            return !task.isPaused;
+          });
+          if (indx > -1) {
+            var _task2 = _this4.queue[indx];
+            _this4.queue = _this4.queue.slice(0, indx).concat(_this4.queue.slice(indx + 1));
+            _this4.runningTasks.push(_task2);
+            _task2 === null || _task2 === void 0 || _task2.task().then(function (res) {
+              var _task2$onFinished;
+              _task2 === null || _task2 === void 0 || (_task2$onFinished = _task2.onFinished) === null || _task2$onFinished === void 0 || _task2$onFinished.call(_task2, [null, res]);
+            }).catch(function (err) {
+              var _task2$onFinished2;
+              _task2 === null || _task2 === void 0 || (_task2$onFinished2 = _task2.onFinished) === null || _task2$onFinished2 === void 0 || _task2$onFinished2.call(_task2, [err, null]);
+            }).finally(function () {
+              _this4.runningTasks = _this4.runningTasks.filter(function (t) {
+                return t.id !== _task2.id;
+              });
+              _task2.isPaused = false;
+              _this4.runTasks();
+            });
+          }
+        }
+      };
+      while ((this.queue.length > 0 && (_this$queue = this.queue) !== null && _this$queue !== void 0 && _this$queue.some(function (task) {
+        return !task.isPaused;
+      }) || this.pausedTasks.length > 0 && (_this$pausedTasks = this.pausedTasks) !== null && _this$pausedTasks !== void 0 && _this$pausedTasks.some(function (task) {
+        return !task.isPaused;
+      })) && this.runningTasks.length < this.maxConcurrency && !this.isPaused) {
+        var _this$queue, _this$pausedTasks;
+        _loop();
+      }
+    }
+
+    // 获取当前指定状态的任务数数量
+  }, {
+    key: "getTaskCount",
+    value: function getTaskCount(type) {
+      switch (type) {
+        case 'all':
+          return this.queue.length + this.runningTasks.length;
+        case 'running':
+          return this.runningTasks.length;
+        case 'notRunning':
+          return this.queue.length;
+        default:
+          return 0;
+      }
+    }
+  }]);
+  return TaskQueue;
+}(BaseTaskQueue);
+export default TaskQueue;

package/dist/esm/Utils/lib/Queue/tools/BinaryHeap.d.ts

@@ -0,0 +1,25 @@
+export declare class BinaryHeap<T> {
+    private compare;
+    private heap;
+    constructor(compare: (a: T, b: T) => number);
+    private parentIndex;
+    private leftChildIndex;
+    private rightChildIndex;
+    private swap;
+    private siftUp;
+    private siftDown;
+    insert(item: T): void;
+    insertMany(items: T[]): void;
+    extractMin(): T | undefined;
+    deleteByIndex(index: number): T | undefined;
+    find(taskFilter: (task: T) => boolean): T | undefined;
+    findIndex(taskFilter: (task: T) => boolean): number;
+    peek(): T | undefined;
+    size(): number;
+    isEmpty(): boolean;
+    clear(): void;
+    forEach(callback: (item: T) => void): void;
+    filter(taskFilter: (task: T) => boolean): BinaryHeap<T>;
+    some(taskFilter: (task: T) => boolean): boolean;
+    every(taskFilter: (task: T) => boolean): boolean;
+}