@libp2p/utils 6.6.2-f1de46607 → 6.6.3-aa25d38ab

package/src/queue/index.ts

@@ -1,6 +1,7 @@
 import { AbortError, TypedEventEmitter } from '@libp2p/interface'
 import { pushable } from 'it-pushable'
 import { raceEvent } from 'race-event'
+import { debounce } from '../debounce.js'
 import { QueueFullError } from '../errors.js'
 import { Job } from './job.js'
 import type { AbortOptions, Metrics } from '@libp2p/interface'
@@ -70,49 +71,49 @@ export interface QueueEvents<JobReturnType, JobOptions extends AbortOptions = Ab
   /**
    * A job is about to start running
    */
-  'active': CustomEvent
+  active: CustomEvent
 
   /**
    * All jobs have finished and the queue is empty
    */
-  'idle': CustomEvent
+  idle: CustomEvent
 
   /**
    * The queue is empty, jobs may be running
    */
-  'empty': CustomEvent
+  empty: CustomEvent
 
   /**
    * A job was added to the queue
    */
-  'add': CustomEvent
+  add: CustomEvent
 
   /**
    * A job has finished or failed
    */
-  'next': CustomEvent
+  next: CustomEvent
 
   /**
    * A job has finished successfully
    */
-  'completed': CustomEvent<JobReturnType>
+  completed: CustomEvent<JobReturnType>
 
   /**
    * A job has failed
    */
-  'error': CustomEvent<Error>
+  error: CustomEvent<Error>
 
   /**
    * Emitted just after `"completed", a job has finished successfully - this
    * event gives access to the job and it's result
    */
-  'success': CustomEvent<QueueJobSuccess<JobReturnType, JobOptions>>
+  success: CustomEvent<QueueJobSuccess<JobReturnType, JobOptions>>
 
   /**
    * Emitted just after `"error", a job has failed - this event gives access to
    * the job and the thrown error
    */
-  'failure': CustomEvent<QueueJobFailure<JobReturnType, JobOptions>>
+  failure: CustomEvent<QueueJobFailure<JobReturnType, JobOptions>>
 }
 
 /**
@@ -149,22 +150,33 @@ export class Queue<JobReturnType = unknown, JobOptions extends AbortOptions = Ab
 
     this.sort = init.sort
     this.queue = []
+
+    this.emitEmpty = debounce(this.emitEmpty.bind(this), 1)
+    this.emitIdle = debounce(this.emitIdle.bind(this), 1)
+  }
+
+  emitEmpty (): void {
+    if (this.size !== 0) {
+      return
+    }
+
+    this.safeDispatchEvent('empty')
+  }
+
+  emitIdle (): void {
+    if (this.running !== 0) {
+      return
+    }
+
+    this.safeDispatchEvent('idle')
   }
 
   private tryToStartAnother (): boolean {
     if (this.size === 0) {
-      // do this in the microtask queue so all job recipients receive the
-      // result before the "empty" event fires
-      queueMicrotask(() => {
-        this.safeDispatchEvent('empty')
-      })
+      this.emitEmpty()
 
       if (this.running === 0) {
-        // do this in the microtask queue so all job recipients receive the
-        // result before the "idle" event fires
-        queueMicrotask(() => {
-          this.safeDispatchEvent('idle')
-        })
+        this.emitIdle()
       }
 
       return false

package/src/repeating-task.ts

@@ -18,7 +18,7 @@ export interface RepeatingTask {
    * Update the amount of time a task will run before the passed abort signal
    * will fire.
    *
-   * * This only affects the next iteration of the task, if it is currently
+   * This only affects the next iteration of the task, if it is currently
    * running, that run will not be interrupted.
    */
   setTimeout(ms: number): void
@@ -83,7 +83,7 @@ export function repeatingTask (fn: (options?: AbortOptions) => void | Promise<vo
   let started = false
 
   return {
-    setInterval: (ms) => {
+    setInterval: (ms): void => {
       interval = ms
 
       // maybe reschedule
@@ -92,14 +92,11 @@ export function repeatingTask (fn: (options?: AbortOptions) => void | Promise<vo
         timeout = setTimeout(runTask, interval)
       }
     },
-    setTimeout: (ms) => {
-      if (options == null) {
-        options = {}
-      }
-
+    setTimeout: (ms): void => {
+      options ??= {}
       options.timeout = ms
     },
-    start: () => {
+    start: (): void => {
       if (started) {
         return
       }
@@ -118,7 +115,7 @@ export function repeatingTask (fn: (options?: AbortOptions) => void | Promise<vo
         timeout = setTimeout(runTask, interval)
       }
     },
-    stop: () => {
+    stop: (): void => {
       clearTimeout(timeout)
       shutdownController?.abort()
       started = false

package/src/stream-to-ma-conn.ts

@@ -34,21 +34,21 @@ export function streamToMaConnection (props: StreamProperties): MultiaddrConnect
 
   // piggyback on `stream.close` invocations to close multiaddr connection
   const streamClose = stream.close.bind(stream)
-  stream.close = async (options) => {
+  stream.close = async (options): Promise<void> => {
     await streamClose(options)
     close(true)
   }
 
   // piggyback on `stream.abort` invocations to close multiaddr connection
   const streamAbort = stream.abort.bind(stream)
-  stream.abort = (err) => {
+  stream.abort = (err): void => {
     streamAbort(err)
     close(true)
   }
 
   // piggyback on `stream.sink` invocations to close multiaddr connection
   const streamSink = stream.sink.bind(stream)
-  stream.sink = async (source) => {
+  stream.sink = async (source): Promise<void> => {
     try {
       await streamSink(
         pipe(
@@ -73,7 +73,7 @@ export function streamToMaConnection (props: StreamProperties): MultiaddrConnect
   const maConn: MultiaddrConnection = {
     log,
     sink: stream.sink,
-    source: (async function * () {
+    source: (async function * (): AsyncGenerator<Uint8ArrayList> {
       try {
         for await (const buf of stream.source) {
           onDataRead?.(buf)