wenay-common 1.0.201 → 1.0.203

package/lib/Common/commonsServer.d.ts

@@ -82,6 +82,7 @@ export type typeNoVoid2<T> = {
 };
 export type UnAwaited<T extends Promise<any>> = T extends Promise<infer R> ? R : never;
 export type UnAwaitedArr<T extends Promise<any>[]> = T extends Promise<infer R>[] ? R[] : never;
+export type ReturnTypePromise<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R extends Promise<any> ? UnAwaited<R> : R : any;
 export type UnObject<T extends object> = T extends {
     [k: string]: infer R;
 } ? R : never;

package/lib/Common/waitRun.d.ts

@@ -2,11 +2,16 @@ export declare function enhancedWaitRun(): {
     throttleAsync: (ms: number, func: () => any | Promise<any>) => void;
     debounceAsync: (ms: number, func: () => any | Promise<any>) => Promise<void>;
 };
+export declare function createAsyncQueue(concurrency?: number): {
+    enqueue: <T>(task: () => Promise<T>) => Promise<T>;
+    onIdle: () => Promise<void>;
+    getQueueSize: () => number;
+};
 export declare function enhancedQueueRun(maxParallelTasks?: number): {
     readonly queueSize: number;
     enqueue(task: () => Promise<any>): void;
     enqueueAndRun(task: () => Promise<any>): void;
-    runAll(): Promise<PromiseSettledResult<void>[]>;
+    runAll(): Promise<void>;
 };
 export declare function waitRun(): {
     refreshAsync: (ms: number, func: () => any | Promise<any>) => void;
@@ -16,5 +21,5 @@ export declare function queueRun(n?: number): {
     readonly size: number;
     next: () => Promise<any>;
     nextRun: () => Promise<any>;
-    run: () => Promise<PromiseSettledResult<void>[]>;
+    run: () => Promise<void>;
 };

package/lib/Common/waitRun.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.enhancedWaitRun = enhancedWaitRun;
+exports.createAsyncQueue = createAsyncQueue;
 exports.enhancedQueueRun = enhancedQueueRun;
 exports.waitRun = waitRun;
 exports.queueRun = queueRun;
@@ -52,40 +53,77 @@ function enhancedWaitRun() {
         },
     };
 }
-function enhancedQueueRun(maxParallelTasks = 5) {
-    const taskQueue = [];
-    const workers = Array(maxParallelTasks).fill(Promise.resolve());
-    const processNextTask = () => {
-        const task = taskQueue.shift();
-        if (task) {
-            return task()
-                .catch((error) => {
-                console.error("Error in task execution:", error);
-            })
-                .finally(processNextTask);
+function createAsyncQueue(concurrency = 1) {
+    let queue = [];
+    let activeCount = 0;
+    let resolveIdle = null;
+    let idlePromise = null;
+    const runNext = () => {
+        if (activeCount >= concurrency || queue.length === 0) {
+            if (activeCount === 0 && queue.length === 0 && resolveIdle) {
+                resolveIdle();
+                resolveIdle = null;
+                idlePromise = null;
+            }
+            return;
         }
+        const task = queue.shift();
+        if (!task)
+            return;
+        activeCount++;
+        task().finally(() => {
+            activeCount--;
+            runNext();
+        });
+        runNext();
     };
-    const checkAndRun = () => {
-        workers.forEach((worker, index) => {
-            if (!worker || worker === Promise.resolve()) {
-                workers[index] = processNextTask() || Promise.resolve();
-            }
+    const enqueue = (task) => {
+        return new Promise((resolve, reject) => {
+            queue.push(async () => {
+                try {
+                    resolve(await task());
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+            runNext();
         });
     };
+    const onIdle = () => {
+        if (!idlePromise) {
+            idlePromise = new Promise((resolve) => {
+                if (activeCount === 0 && queue.length === 0) {
+                    resolve();
+                }
+                else {
+                    resolveIdle = resolve;
+                }
+            });
+        }
+        return idlePromise;
+    };
+    const getQueueSize = () => queue.length;
+    return {
+        enqueue,
+        onIdle,
+        getQueueSize,
+    };
+}
+function enhancedQueueRun(maxParallelTasks = 5) {
+    const tr = createAsyncQueue(maxParallelTasks);
     return {
         get queueSize() {
-            return taskQueue.length;
+            return tr.getQueueSize();
         },
         enqueue(task) {
-            taskQueue.push(task);
+            tr.enqueue(task);
         },
         enqueueAndRun(task) {
-            taskQueue.push(task);
-            checkAndRun();
+            tr.enqueue(task);
         },
         runAll() {
-            checkAndRun();
-            return Promise.allSettled(workers);
+            return tr.onIdle();
         },
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wenay-common",
-  "version": "1.0.201",
+  "version": "1.0.203",
   "description": "Common library",
   "strict": true,
   "main": "lib/index.js",