@kontsedal/olas-core 0.0.1 → 0.0.2

package/src/timing/debounced.ts

@@ -5,15 +5,22 @@ import type { ReadSignal } from '../signals/types'
  * Lag a signal by `ms`. The returned signal updates only after the source has
  * been unchanged for `ms`. Each new write resets the timer.
  *
- * No lifecycle — the internal effect runs for the lifetime of the program.
- * Use inside a controller closure so it dies with the closure.
+ * Pass `options.signal` (an `AbortSignal`) to tie the internal effect to a
+ * lifecycle — when the signal aborts the effect disposes, the pending timer
+ * clears, and the subscriber chain on `source` drops. Without `signal`, the
+ * effect lives as long as `source` does; pass a signal whenever the source
+ * outlives the consumer.
  */
-export function debounced<T>(source: ReadSignal<T>, ms: number): ReadSignal<T> {
+export function debounced<T>(
+  source: ReadSignal<T>,
+  ms: number,
+  options?: { signal?: AbortSignal },
+): ReadSignal<T> {
   const out = signal<T>(source.peek())
   let timer: ReturnType<typeof setTimeout> | null = null
   let initial = true
 
-  effect(() => {
+  const dispose = effect(() => {
     const value = source.value
     if (initial) {
       // The first effect run reads the source for tracking; we already
@@ -28,5 +35,18 @@ export function debounced<T>(source: ReadSignal<T>, ms: number): ReadSignal<T> {
     }, ms)
   })
 
+  const sig = options?.signal
+  if (sig) {
+    const stop = () => {
+      if (timer != null) {
+        clearTimeout(timer)
+        timer = null
+      }
+      dispose()
+    }
+    if (sig.aborted) stop()
+    else sig.addEventListener('abort', stop, { once: true })
+  }
+
   return out
 }

package/src/timing/throttled.ts

@@ -6,16 +6,22 @@ import type { ReadSignal } from '../signals/types'
  * The first change passes through immediately. Subsequent changes within the
  * window are coalesced; the latest value is emitted when the window expires.
  *
- * No lifecycle — see debounced() note.
+ * Pass `options.signal` to tie the internal effect to a lifecycle — when the
+ * signal aborts the effect disposes and any pending trailing timer clears.
+ * Without `signal`, the effect lives as long as `source` does.
  */
-export function throttled<T>(source: ReadSignal<T>, ms: number): ReadSignal<T> {
+export function throttled<T>(
+  source: ReadSignal<T>,
+  ms: number,
+  options?: { signal?: AbortSignal },
+): ReadSignal<T> {
   const out = signal<T>(source.peek())
   let lastEmit = Number.NEGATIVE_INFINITY
   let trailingTimer: ReturnType<typeof setTimeout> | null = null
   let trailingValue: T = source.peek()
   let initial = true
 
-  effect(() => {
+  const dispose = effect(() => {
     const value = source.value
     if (initial) {
       initial = false
@@ -42,5 +48,18 @@ export function throttled<T>(source: ReadSignal<T>, ms: number): ReadSignal<T> {
     }
   })
 
+  const sig = options?.signal
+  if (sig) {
+    const stop = () => {
+      if (trailingTimer != null) {
+        clearTimeout(trailingTimer)
+        trailingTimer = null
+      }
+      dispose()
+    }
+    if (sig.aborted) stop()
+    else sig.addEventListener('abort', stop, { once: true })
+  }
+
   return out
 }

package/src/utils.ts

@@ -1,14 +1,18 @@
 /**
- * True iff `err` is an AbortError. Used to filter superseded latest-wins
- * mutations and aborted fetches from genuine failures.
+ * True iff `err` looks like an AbortError. Matches the standard `DOMException`
+ * shape thrown by `AbortController` AND any object whose `name === 'AbortError'`
+ * — that covers axios / msw / user-thrown plain Errors that signal abort.
  *
- * Spec: §20.12 — checks `err instanceof DOMException && err.name === 'AbortError'`.
- * Node 17+ exposes a global DOMException, so this works server-side too.
+ * Spec: §20.12. Node 17+ exposes a global DOMException, so the instanceof
+ * branch works server-side; the name-based branch is the portable fallback.
  */
 export function isAbortError(err: unknown): boolean {
   if (typeof DOMException !== 'undefined' && err instanceof DOMException) {
     return err.name === 'AbortError'
   }
+  if (err != null && typeof err === 'object' && 'name' in err) {
+    return (err as { name: unknown }).name === 'AbortError'
+  }
   return false
 }