tools-min-ns 1.18.7 → 1.18.8

package/README.md

@@ -5,6 +5,8 @@ pnpm i tools-min-ns --save
 ```
 
 # updates
+## v1.18.8
+fix: RequestUtil handleRequests并发请求优化
 ## v1.18.7
 fix: 不需要那么严格的URL正则
 

package/esm/request/RequestUtil.d.ts

@@ -8,7 +8,7 @@ import mgop, { setDefaultHeader } from './mgop';
 import uniRquestFn from './uniRquest';
 import jsonpFn, { jsonpRquest as jsonpRquestFn } from './jsonp';
 import nsPromiseFn from './nsPromiseFn';
-export type PromiseInput<T> = Array<(() => Promise<T>) | Promise<T>> | (() => Promise<T>) | Promise<T>;
+export type PromiseInput<T> = (() => Promise<T>)[] | (() => Promise<T>) | Promise<T>;
 declare namespace RequestUtil {
     /** @name 浙里办请求工具设置默认请求头 */
     export const mgopSetDefaultHeader: typeof setDefaultHeader;

package/esm/request/RequestUtil.js

@@ -113,6 +113,37 @@ var __generator = this && this.__generator || function (thisArg, body) {
     };
   }
 };
+var __read = this && this.__read || function (o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o),
+    r,
+    ar = [],
+    e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error) {
+    e = {
+      error: error
+    };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+};
+var __spreadArray = this && this.__spreadArray || function (to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+};
 /**
  * 请求工具
  * @description
@@ -175,43 +206,52 @@ var RequestUtil;
    */
   function handleRequests(requests, options) {
     return __awaiter(this, void 0, void 0, function () {
-      // 存储所有请求的结果
-      // 定义一个递归函数，用于处理请求并控制并发数量
       function processRequest() {
         return __awaiter(this, void 0, void 0, function () {
-          var res, result;
+          var resFn, result, progress, error_1;
           return __generator(this, function (_a) {
             switch (_a.label) {
               case 0:
-                if (!functionArray.length) return [2 /*return*/];
-                res = functionArray.shift();
-                if (!res) return [2 /*return*/];
-                return [4 /*yield*/, res()];
+                if (!(functionArray.length > 0)) return [3 /*break*/, 6];
+                resFn = functionArray.shift();
+                if (!resFn) return [3 /*break*/, 0];
+                _a.label = 1;
               case 1:
-                result = _a.sent();
-                // 执行请求并等待其完成
-                results.push(result);
-                // 将结果存储
-                // 递归调用，确保有新的请求补充进去
-                return [4 /*yield*/, processRequest()];
+                _a.trys.push([1, 4,, 5]);
+                return [4 /*yield*/, resFn()];
               case 2:
-                // 将结果存储
-                // 递归调用，确保有新的请求补充进去
+                result = _a.sent();
+                results.push(result); // 顺序由完成顺序决定
+                // 更新进度（使用互斥锁确保原子性）
+                return [4 /*yield*/, progressLock.acquire()];
+              case 3:
+                // 更新进度（使用互斥锁确保原子性）
                 _a.sent();
                 loaded += 1;
+                progress = loaded / resLength;
                 onUploadProgress === null || onUploadProgress === void 0 ? void 0 : onUploadProgress({
                   total: resLength,
                   loaded: loaded,
-                  progress: loaded / resLength,
+                  progress: progress,
                   nowResponse: result,
-                  endResponses: results
+                  endResponses: __spreadArray([], __read(results), false)
                 });
+                progressLock.release();
+                return [3 /*break*/, 5];
+              case 4:
+                error_1 = _a.sent();
+                // 错误处理（根据需求决定是否抛出或记录）
+                console.error('请求失败:', error_1);
+                throw error_1;
+              case 5:
+                return [3 /*break*/, 0];
+              case 6:
                 return [2 /*return*/];
             }
           });
         });
       }
-      var _a, _b, limit, onUploadProgress, requestArray, functionArray, resLength, results, loaded, concurrent;
+      var _a, _b, limit, onUploadProgress, requestArray, functionArray, resLength, results, loaded, progressLock, concurrent;
       return __generator(this, function (_c) {
         switch (_c.label) {
           case 0:
@@ -225,23 +265,48 @@ var RequestUtil;
             resLength = functionArray.length;
             results = [];
             loaded = 0;
+            progressLock = new AsyncLock();
             concurrent = Array.from({
               length: Math.min(limit, resLength)
             }, function () {
               return processRequest();
             });
-            // 等待所有并发的请求完成
             return [4 /*yield*/, Promise.all(concurrent)];
           case 1:
-            // 等待所有并发的请求完成
             _c.sent();
             return [2 /*return*/, results];
-          // 返回所有请求的结果
         }
       });
     });
   }
   RequestUtil.handleRequests = handleRequests;
+  // 互斥锁实现（简化版）
+  var AsyncLock = /** @class */function () {
+    function AsyncLock() {
+      this._locked = false;
+      this._queue = [];
+    }
+    AsyncLock.prototype.acquire = function () {
+      var _this = this;
+      return new Promise(function (resolve) {
+        var _tryAcquire = function tryAcquire() {
+          if (!_this._locked) {
+            _this._locked = true;
+            resolve();
+          } else {
+            _this._queue.push(_tryAcquire);
+          }
+        };
+        _tryAcquire();
+      });
+    };
+    AsyncLock.prototype.release = function () {
+      this._locked = false;
+      var next = this._queue.shift();
+      if (next) next();
+    };
+    return AsyncLock;
+  }();
   /**
   * 封装多个 Promise 方法，返回 [错误, 数据, 停止状态] 格式
   * @param {Array<Function | Promise> | Function | Promise} input - 返回 Promise 的函数数组或 Promise 数组，或者单个函数或 Promise

package/lib/request/RequestUtil.d.ts

@@ -8,7 +8,7 @@ import mgop, { setDefaultHeader } from './mgop';
 import uniRquestFn from './uniRquest';
 import jsonpFn, { jsonpRquest as jsonpRquestFn } from './jsonp';
 import nsPromiseFn from './nsPromiseFn';
-export type PromiseInput<T> = Array<(() => Promise<T>) | Promise<T>> | (() => Promise<T>) | Promise<T>;
+export type PromiseInput<T> = (() => Promise<T>)[] | (() => Promise<T>) | Promise<T>;
 declare namespace RequestUtil {
     /** @name 浙里办请求工具设置默认请求头 */
     export const mgopSetDefaultHeader: typeof setDefaultHeader;

package/lib/request/RequestUtil.js

@@ -146,6 +146,37 @@ var __generator = this && this.__generator || function (thisArg, body) {
     };
   }
 };
+var __read = this && this.__read || function (o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o),
+    r,
+    ar = [],
+    e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error) {
+    e = {
+      error: error
+    };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+};
+var __spreadArray = this && this.__spreadArray || function (to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+};
 var __importDefault = this && this.__importDefault || function (mod) {
   return mod && mod.__esModule ? mod : {
     "default": mod
@@ -216,43 +247,52 @@ var RequestUtil;
    */
   function handleRequests(requests, options) {
     return __awaiter(this, void 0, void 0, function () {
-      // 存储所有请求的结果
-      // 定义一个递归函数，用于处理请求并控制并发数量
       function processRequest() {
         return __awaiter(this, void 0, void 0, function () {
-          var res, result;
+          var resFn, result, progress, error_1;
           return __generator(this, function (_a) {
             switch (_a.label) {
               case 0:
-                if (!functionArray.length) return [2 /*return*/];
-                res = functionArray.shift();
-                if (!res) return [2 /*return*/];
-                return [4 /*yield*/, res()];
+                if (!(functionArray.length > 0)) return [3 /*break*/, 6];
+                resFn = functionArray.shift();
+                if (!resFn) return [3 /*break*/, 0];
+                _a.label = 1;
               case 1:
-                result = _a.sent();
-                // 执行请求并等待其完成
-                results.push(result);
-                // 将结果存储
-                // 递归调用，确保有新的请求补充进去
-                return [4 /*yield*/, processRequest()];
+                _a.trys.push([1, 4,, 5]);
+                return [4 /*yield*/, resFn()];
               case 2:
-                // 将结果存储
-                // 递归调用，确保有新的请求补充进去
+                result = _a.sent();
+                results.push(result); // 顺序由完成顺序决定
+                // 更新进度（使用互斥锁确保原子性）
+                return [4 /*yield*/, progressLock.acquire()];
+              case 3:
+                // 更新进度（使用互斥锁确保原子性）
                 _a.sent();
                 loaded += 1;
+                progress = loaded / resLength;
                 onUploadProgress === null || onUploadProgress === void 0 ? void 0 : onUploadProgress({
                   total: resLength,
                   loaded: loaded,
-                  progress: loaded / resLength,
+                  progress: progress,
                   nowResponse: result,
-                  endResponses: results
+                  endResponses: __spreadArray([], __read(results), false)
                 });
+                progressLock.release();
+                return [3 /*break*/, 5];
+              case 4:
+                error_1 = _a.sent();
+                // 错误处理（根据需求决定是否抛出或记录）
+                console.error('请求失败:', error_1);
+                throw error_1;
+              case 5:
+                return [3 /*break*/, 0];
+              case 6:
                 return [2 /*return*/];
             }
           });
         });
       }
-      var _a, _b, limit, onUploadProgress, requestArray, functionArray, resLength, results, loaded, concurrent;
+      var _a, _b, limit, onUploadProgress, requestArray, functionArray, resLength, results, loaded, progressLock, concurrent;
       return __generator(this, function (_c) {
         switch (_c.label) {
           case 0:
@@ -266,23 +306,48 @@ var RequestUtil;
             resLength = functionArray.length;
             results = [];
             loaded = 0;
+            progressLock = new AsyncLock();
             concurrent = Array.from({
               length: Math.min(limit, resLength)
             }, function () {
               return processRequest();
             });
-            // 等待所有并发的请求完成
             return [4 /*yield*/, Promise.all(concurrent)];
           case 1:
-            // 等待所有并发的请求完成
             _c.sent();
             return [2 /*return*/, results];
-          // 返回所有请求的结果
         }
       });
     });
   }
   RequestUtil.handleRequests = handleRequests;
+  // 互斥锁实现（简化版）
+  var AsyncLock = /** @class */function () {
+    function AsyncLock() {
+      this._locked = false;
+      this._queue = [];
+    }
+    AsyncLock.prototype.acquire = function () {
+      var _this = this;
+      return new Promise(function (resolve) {
+        var _tryAcquire = function tryAcquire() {
+          if (!_this._locked) {
+            _this._locked = true;
+            resolve();
+          } else {
+            _this._queue.push(_tryAcquire);
+          }
+        };
+        _tryAcquire();
+      });
+    };
+    AsyncLock.prototype.release = function () {
+      this._locked = false;
+      var next = this._queue.shift();
+      if (next) next();
+    };
+    return AsyncLock;
+  }();
   /**
   * 封装多个 Promise 方法，返回 [错误, 数据, 停止状态] 格式
   * @param {Array<Function | Promise> | Function | Promise} input - 返回 Promise 的函数数组或 Promise 数组，或者单个函数或 Promise

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tools-min-ns",
   "description": "工具包适用于前端以及node",
-  "version": "1.18.7",
+  "version": "1.18.8",
   "main": "lib/index.js",
   "license": "MIT",
   "author": "nanshen",