@meshconnect/uwc-core 0.10.1 → 1.0.1

package/src/utils/abort.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect } from 'vitest'
+import { raceAbort } from './abort'
+
+describe('raceAbort', () => {
+  it('returns the promise unchanged when no signal is provided', async () => {
+    const p = Promise.resolve(42)
+    await expect(raceAbort(p)).resolves.toBe(42)
+  })
+
+  it('resolves with the promise value when the signal stays unset', async () => {
+    const controller = new AbortController()
+    const p = Promise.resolve('ok')
+    await expect(raceAbort(p, controller.signal)).resolves.toBe('ok')
+  })
+
+  it('rejects with the signal reason when already aborted', async () => {
+    const controller = new AbortController()
+    const reason = new Error('cancelled')
+    controller.abort(reason)
+    await expect(
+      raceAbort(new Promise(() => {}), controller.signal)
+    ).rejects.toBe(reason)
+  })
+
+  it('rejects mid-flight when the signal fires while the promise is pending', async () => {
+    const controller = new AbortController()
+    const pending: Promise<unknown> = new Promise(() => {})
+
+    const raced = raceAbort(pending, controller.signal)
+    controller.abort()
+
+    await expect(raced).rejects.toMatchObject({ name: 'AbortError' })
+  })
+
+  it('forwards the underlying promise rejection when no abort happens', async () => {
+    const controller = new AbortController()
+    const err = new Error('underlying')
+    await expect(
+      raceAbort(Promise.reject(err), controller.signal)
+    ).rejects.toBe(err)
+  })
+
+  it('removes its abort listener after the promise settles', async () => {
+    const controller = new AbortController()
+    let listenerCount = 0
+    const originalAdd = controller.signal.addEventListener.bind(
+      controller.signal
+    )
+    const originalRemove = controller.signal.removeEventListener.bind(
+      controller.signal
+    )
+    controller.signal.addEventListener = ((
+      ...args: Parameters<typeof originalAdd>
+    ) => {
+      listenerCount++
+      return originalAdd(...args)
+    }) as typeof originalAdd
+    controller.signal.removeEventListener = ((
+      ...args: Parameters<typeof originalRemove>
+    ) => {
+      listenerCount--
+      return originalRemove(...args)
+    }) as typeof originalRemove
+
+    await raceAbort(Promise.resolve('done'), controller.signal)
+    expect(listenerCount).toBe(0)
+  })
+})

package/src/utils/abort.ts

@@ -0,0 +1,38 @@
+/**
+ * Race a promise against an AbortSignal. If the signal fires before the
+ * promise settles, the returned promise rejects immediately with the signal's
+ * `reason` (defaulting to a `DOMException('Aborted', 'AbortError')` to match
+ * the platform contract).
+ *
+ * The underlying operation is NOT cancelled — wallet prompts in particular
+ * can't usually be aborted by the dapp side. What this guarantees is that
+ * the CALLER's await returns promptly so the UI can move on; any late result
+ * from the underlying promise is discarded (a `.then` after rejection is a
+ * no-op for the awaiter).
+ */
+export function raceAbort<T>(
+  promise: Promise<T>,
+  signal?: AbortSignal
+): Promise<T> {
+  if (!signal) return promise
+  if (signal.aborted) {
+    return Promise.reject(
+      signal.reason ?? new DOMException('Aborted', 'AbortError')
+    )
+  }
+  return new Promise<T>((resolve, reject) => {
+    const onAbort = () =>
+      reject(signal.reason ?? new DOMException('Aborted', 'AbortError'))
+    signal.addEventListener('abort', onAbort, { once: true })
+    promise.then(
+      value => {
+        signal.removeEventListener('abort', onAbort)
+        resolve(value)
+      },
+      error => {
+        signal.removeEventListener('abort', onAbort)
+        reject(error)
+      }
+    )
+  })
+}