feat: withLock support this scope

README.md

@@ -25,13 +25,13 @@ Calling `withLock` with the same `scope` and `key` will ensure that the callback
 ```typescript
 import {withLock} from "lifecycle-utils";
 
-const scope = {}; // can be a reference to any object you like
+const scope = {name: 'Tommy'}; // can be a reference to any object you like
 const startTime = Date.now();
 
 async function doSomething(index: number): number {
-    return await withLock(scope, "myKey", async () => {
+    return await withLock(scope, "myKey", async function () {
         await new Promise(resolve => setTimeout(resolve, 1000));
-        console.log("index:", index, "time:", Date.now() - startTime);
+        console.log("index:", index, "time:", Date.now() - startTime, "name:", this.name);
         return 42;
     });
 }

src/withLock.ts

@@ -3,14 +3,14 @@ const locks = new Map<any, Map<string, Promise<any>>>();
 /**
  * Only allow one instance of the callback to run at a time for a given `scope` and `key`.
  */
-export async function withLock<ReturnType>(scope: any, key: string, callback: () => Promise<ReturnType>): Promise<ReturnType>;
-export async function withLock<ReturnType>(
-    scope: any, key: string, acquireLockSignal: AbortSignal | undefined, callback: () => Promise<ReturnType>
+export async function withLock<ReturnType, ScopeType>(scope: ScopeType, key: string, callback: (this: ScopeType) => Promise<ReturnType>): Promise<ReturnType>;
+export async function withLock<ReturnType, ScopeType>(
+    scope: ScopeType, key: string, acquireLockSignal: AbortSignal | undefined, callback: (this: ScopeType) => Promise<ReturnType>
 ): Promise<ReturnType>;
-export async function withLock<ReturnType>(
-    scope: any,
+export async function withLock<ReturnType, ScopeType>(
+    scope: ScopeType,
     key: string,
-    acquireLockSignalOrCallback: AbortSignal | undefined | (() => Promise<ReturnType>),
+    acquireLockSignalOrCallback: AbortSignal | undefined | ((this: ScopeType) => Promise<ReturnType>),
     callback?: () => Promise<ReturnType>
 ): Promise<ReturnType> {
     let acquireLockSignal: AbortSignal | undefined = undefined;
@@ -47,7 +47,7 @@ export async function withLock<ReturnType>(
             throw acquireLockSignal.reason;
     }
 
-    const promise = callback();
+    const promise = callback.call(scope);
 
     if (!locks.has(scope))
         locks.set(scope, new Map());

test/withLock.test.ts

@@ -300,6 +300,18 @@ describe("withLock", () => {
             // do nothing
         }
     });
+
+    test("this scope works", async () => {
+        const scope = {data: 1};
+        const key = "key";
+
+        let calls = 0;
+        await withLock(scope, key, async function (){
+            expect(this).toBe(scope);
+            calls++;
+        });
+        expect(calls).toBe(1);
+    });
 });