superlock 1.2.10 → 1.3.1

package/README.md

@@ -48,6 +48,26 @@ console.log(executions)
 
 Just call `withLock(n)` being `n` the maximum of concurrency desired for the lock.
 
+### with cancellation
+
+Pass an [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) to drop an acquisition that is still waiting in the queue — handy for shedding work whose caller already gave up (a timed-out request, a disconnected client):
+
+```js
+const { withLock } = require('superlock')
+
+const lock = withLock()
+const controller = new AbortController()
+
+const pending = lock(() => doWork(), controller.signal)
+
+// caller no longer needs the result: give the queued slot back
+controller.abort()
+
+await pending // resolves `undefined`; `doWork` never runs
+```
+
+If the signal aborts **before** the slot is granted, the acquisition is dropped: it never takes a slot and the wrapped function never runs. Aborting **after** the slot is granted is a no-op (the work is already running). Aborting is silent — it resolves instead of throwing — so shedding a lot of queued work never produces rejections to handle.
+
 ## API
 
 ### withLock([concurrency=1])
@@ -66,6 +86,16 @@ await lock(() => {
 
 The lock will be automatically released after your code execution is done even if an error occurred, avoiding [deadlock](https://en.wikipedia.org/wiki/Deadlock) situations.
 
+It also accepts an optional `AbortSignal` as second argument:
+
+```js
+await lock(() => {
+  /* your code execution */
+}, signal)
+```
+
+If `signal` aborts while the call is still queued, the function is skipped and the call resolves `undefined` instead of running. Aborting after the slot is granted has no effect.
+
 #### concurrency
 
 Type: `number`<br>
@@ -73,6 +103,12 @@ Default: `1`
 
 It sets the maximum of concurrency allowed for the lock.
 
+#### signal
+
+Type: `AbortSignal`
+
+When provided, aborting it drops the acquisition while it is still waiting in the queue: no slot is taken and the wrapped function never runs.
+
 ### .isLocked()
 
 Type: `boolean`

package/package.json

@@ -2,7 +2,7 @@
   "name": "superlock",
   "description": "The most simple mutex/semaphore implementation",
   "homepage": "https://github.com/Kikobeats/superlock",
-  "version": "1.2.10",
+  "version": "1.3.1",
   "types": "src/index.d.ts",
   "main": "src/index.js",
   "exports": {

package/src/create.js

@@ -7,33 +7,37 @@ class Node {
 }
 
 class LinkedList {
+  constructor () {
+    this.length = 0
+  }
+
   enqueue (data) {
-    if (!this.head) {
-      this.head = new Node(data)
-    } else {
-      let current = this.head
-      while (current.next) {
-        current = current.next
-      }
-      current.next = new Node(data)
-    }
+    const node = new Node(data)
+    node.prev = this.tail
+    if (this.tail) this.tail.next = node
+    else this.head = node
+    this.tail = node
+    this.length++
+    return node
   }
 
   dequeue () {
     if (!this.head) return
-    const data = this.head.data
-    this.head = this.head.next
+    const { data } = this.head
+    this.remove(this.head)
     return data
   }
 
+  remove (node) {
+    if (node.prev) node.prev.next = node.next
+    else this.head = node.next
+    if (node.next) node.next.prev = node.prev
+    else this.tail = node.prev
+    this.length--
+  }
+
   size () {
-    let count = 0
-    let current = this.head
-    while (current) {
-      count++
-      current = current.next
-    }
-    return count
+    return this.length
   }
 }
 
@@ -42,8 +46,8 @@ module.exports = (slots = 1) => {
 
   const release = () => {
     ++slots
-    const fn = queue.dequeue()
-    if (fn !== undefined) fn()
+    const waiter = queue.dequeue()
+    if (waiter) return waiter.acquire()
   }
 
   const acquire = resolve => {
@@ -51,10 +55,26 @@ module.exports = (slots = 1) => {
     resolve(release)
   }
 
-  const lock = () =>
-    new Promise(resolve =>
-      lock.isLocked() ? queue.enqueue(() => acquire(resolve)) : acquire(resolve)
-    )
+  const lock = signal =>
+    new Promise(resolve => {
+      if (signal?.aborted) return resolve(null)
+      if (!lock.isLocked()) return acquire(resolve)
+
+      const waiter = { acquire: () => acquire(resolve) }
+      const node = queue.enqueue(waiter)
+
+      if (signal !== undefined) {
+        const onAbort = () => {
+          queue.remove(node)
+          resolve(null)
+        }
+        waiter.acquire = () => {
+          signal.removeEventListener('abort', onAbort)
+          acquire(resolve)
+        }
+        signal.addEventListener('abort', onAbort, { once: true })
+      }
+    })
 
   lock.isLocked = () => slots === 0
 

package/src/index.d.ts

@@ -1,17 +1,19 @@
 declare type Release = () => void;
 declare type Acquire = (resolve: (release: Release) => void) => void;
-declare type Lock = () => Promise<Release>;
+declare type Lock = (signal?: AbortSignal) => Promise<Release | null>;
 
 interface LockInterface extends Lock {
   isLocked: () => boolean;
+  awaiting: () => number;
 }
 
 declare function createLock(slots?: number): LockInterface;
 
-declare type WithLock = <T>(fn: () => Promise<T>) => Promise<T>;
+declare type WithLock = <T>(fn: () => Promise<T>, signal?: AbortSignal) => Promise<T | undefined>;
 
 interface WithLockInterface extends WithLock {
   isLocked: () => boolean;
+  awaiting: () => number;
 }
 
 declare function withLock(opts?: number): WithLockInterface;

package/src/index.js

@@ -5,8 +5,9 @@ const createLock = require('./create')
 const withLock = opts => {
   const lock = createLock(opts)
 
-  const withLock = async fn => {
-    const release = await lock()
+  const withLock = async (fn, signal) => {
+    const release = await lock(signal)
+    if (!release) return
     try {
       return await fn()
     } finally {