async-queue-runner 1.0.2 → 1.1.0

package/_cjs/locking.js

@@ -12,39 +12,52 @@ function reversePromiseFactory() {
     };
 }
 class LockManager {
-    lockedScopes = new Map();
+    queuedScopes = new Map();
+    manualLocks = new Map();
     isLocked(scope) {
-        return this.lockedScopes.has(scope);
+        return this.queuedScopes.has(scope);
     }
     lock(scope) {
-        if (this.lockedScopes.has(scope)) {
+        if (this.queuedScopes.has(scope)) {
             throw new Error(`scope "${scope}" is already locked`);
         }
-        this.lockedScopes.set(scope, reversePromiseFactory());
+        const manual = reversePromiseFactory();
+        this.manualLocks.set(scope, manual);
+        this.queuedScopes.set(scope, manual.promise);
     }
     unlock(scope) {
-        if (!this.lockedScopes.has(scope)) {
+        const manual = this.manualLocks.get(scope);
+        if (!manual) {
             return;
         }
-        this.lockedScopes.get(scope).resolve();
-        this.lockedScopes.delete(scope);
+        manual.resolve();
+        this.manualLocks.delete(scope);
+        if (this.queuedScopes.get(scope) === manual.promise) {
+            this.queuedScopes.delete(scope);
+        }
     }
     wait(scope) {
-        if (!this.lockedScopes.has(scope)) {
+        const tail = this.queuedScopes.get(scope);
+        if (!tail) {
             return Promise.resolve();
         }
-        return this.lockedScopes.get(scope).promise;
+        return tail;
     }
     async runWithLock(scope, fn) {
-        if (this.isLocked(scope)) {
-            await this.wait(scope);
+        const previous = this.queuedScopes.get(scope);
+        const current = reversePromiseFactory();
+        this.queuedScopes.set(scope, current.promise);
+        if (previous) {
+            await previous;
         }
-        this.lock(scope);
         try {
             await fn();
         }
         finally {
-            this.unlock(scope);
+            current.resolve();
+            if (this.queuedScopes.get(scope) === current.promise && !this.manualLocks.has(scope)) {
+                this.queuedScopes.delete(scope);
+            }
         }
     }
 }

package/_esm/locking.js

@@ -9,39 +9,52 @@ function reversePromiseFactory() {
     };
 }
 export class LockManager {
-    lockedScopes = new Map();
+    queuedScopes = new Map();
+    manualLocks = new Map();
     isLocked(scope) {
-        return this.lockedScopes.has(scope);
+        return this.queuedScopes.has(scope);
     }
     lock(scope) {
-        if (this.lockedScopes.has(scope)) {
+        if (this.queuedScopes.has(scope)) {
             throw new Error(`scope "${scope}" is already locked`);
         }
-        this.lockedScopes.set(scope, reversePromiseFactory());
+        const manual = reversePromiseFactory();
+        this.manualLocks.set(scope, manual);
+        this.queuedScopes.set(scope, manual.promise);
     }
     unlock(scope) {
-        if (!this.lockedScopes.has(scope)) {
+        const manual = this.manualLocks.get(scope);
+        if (!manual) {
             return;
         }
-        this.lockedScopes.get(scope).resolve();
-        this.lockedScopes.delete(scope);
+        manual.resolve();
+        this.manualLocks.delete(scope);
+        if (this.queuedScopes.get(scope) === manual.promise) {
+            this.queuedScopes.delete(scope);
+        }
     }
     wait(scope) {
-        if (!this.lockedScopes.has(scope)) {
+        const tail = this.queuedScopes.get(scope);
+        if (!tail) {
             return Promise.resolve();
         }
-        return this.lockedScopes.get(scope).promise;
+        return tail;
     }
     async runWithLock(scope, fn) {
-        if (this.isLocked(scope)) {
-            await this.wait(scope);
+        const previous = this.queuedScopes.get(scope);
+        const current = reversePromiseFactory();
+        this.queuedScopes.set(scope, current.promise);
+        if (previous) {
+            await previous;
         }
-        this.lock(scope);
         try {
             await fn();
         }
         finally {
-            this.unlock(scope);
+            current.resolve();
+            if (this.queuedScopes.get(scope) === current.promise && !this.manualLocks.has(scope)) {
+                this.queuedScopes.delete(scope);
+            }
         }
     }
 }

package/_types/locking.d.ts

@@ -7,7 +7,8 @@ export type LockingContext = {
     runWithLock: (scope: string, fn: () => Promise<void>) => Promise<void>;
 };
 export declare class LockManager implements LockingContext {
-    private lockedScopes;
+    private queuedScopes;
+    private manualLocks;
     isLocked(scope: string): boolean;
     lock(scope: string): void;
     unlock(scope: string): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "async-queue-runner",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Library to run in parallel extendable queue of tasks",
   "scripts": {
     "compile": "tsc --project ./tsconfig.json",