deps(dev): bump aegir from 37.12.1 to 38.1.0 (#20)

* deps(dev): bump aegir from 37.12.1 to 38.1.0

Bumps [aegir](https://github.com/ipfs/aegir) from 37.12.1 to 38.1.0.
- [Release notes](https://github.com/ipfs/aegir/releases)
- [Changelog](https://github.com/ipfs/aegir/blob/master/CHANGELOG.md)
- [Commits](ipfs/aegir@v37.12.1...v38.1.0)

---
updated-dependencies:
- dependency-name: aegir
  dependency-type: direct:development
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <[email protected]>

* chore: fix linting

Signed-off-by: dependabot[bot] <[email protected]>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: achingbrain <[email protected]>

Author: dependabot[bot]

package.json

@@ -185,7 +185,7 @@
     "@dapplion/benchmark": "^0.2.2",
     "@libp2p/interface-stream-muxer-compliance-tests": "^6.0.0",
     "@libp2p/mplex": "^7.0.0",
-    "aegir": "^37.9.1",
+    "aegir": "^38.1.0",
     "it-drain": "^2.0.0",
     "it-pair": "2.0.3",
     "it-stream-types": "^1.0.4"

src/decode.ts

@@ -55,7 +55,7 @@ export class Decoder {
    * Note: If `readData` is emitted, it _must_ be called before the next iteration
    * Otherwise an error is thrown
    */
-  async * emitFrames (): AsyncGenerator<{header: FrameHeader, readData?: () => Promise<Uint8ArrayList>}> {
+  async * emitFrames (): AsyncGenerator<{ header: FrameHeader, readData?: () => Promise<Uint8ArrayList> }> {
     for await (const chunk of this.source) {
       this.buffer.append(chunk)
 

src/muxer.ts

@@ -119,7 +119,7 @@ export class YamuxMuxer implements StreamMuxer {
         reason = GoAwayCode.NormalTermination
       } catch (err: unknown) {
         // either a protocol or internal error
-        const errCode = (err as {code: string}).code
+        const errCode = (err as { code: string }).code
         if (PROTOCOL_ERRORS.has(errCode)) {
           this.log?.error('protocol error in sink', err)
           reason = GoAwayCode.ProtocolError
@@ -204,16 +204,16 @@ export class YamuxMuxer implements StreamMuxer {
     // An active ping does not yet exist, handle the process here
     if (this.activePing === undefined) {
       // create active ping
-      let _resolve = () => {}
+      let _resolve = (): void => {}
       this.activePing = {
         id: this.nextPingID++,
         // this promise awaits resolution or the close controller aborting
         promise: new Promise<void>((resolve, reject) => {
-          const closed = () => {
+          const closed = (): void => {
             reject(errcode(new Error('muxer closed locally'), ERR_MUXER_LOCAL_CLOSED))
           }
           this.closeController.signal.addEventListener('abort', closed, { once: true })
-          _resolve = () => {
+          _resolve = (): void => {
             this.closeController.signal.removeEventListener('abort', closed)
             resolve()
           }
@@ -338,7 +338,7 @@ export class YamuxMuxer implements StreamMuxer {
   }
 
   private async keepAliveLoop (): Promise<void> {
-    const abortPromise = new Promise((_resolve, reject) => this.closeController.signal.addEventListener('abort', reject, { once: true }))
+    const abortPromise = new Promise((_resolve, reject) => { this.closeController.signal.addEventListener('abort', reject, { once: true }) })
     this.log?.('muxer keepalive enabled interval=%s', this.config.keepAliveInterval)
     while (true) {
       let timeoutId
@@ -369,9 +369,9 @@ export class YamuxMuxer implements StreamMuxer {
     if (streamID === 0) {
       switch (type) {
         case FrameType.Ping:
-          return this.handlePing(header)
+        { this.handlePing(header); return }
         case FrameType.GoAway:
-          return this.handleGoAway(length)
+        { this.handleGoAway(length); return }
         default:
           // Invalid state
           throw errcode(new Error('Invalid frame type'), ERR_INVALID_FRAME, { header })
@@ -380,7 +380,7 @@ export class YamuxMuxer implements StreamMuxer {
       switch (header.type) {
         case FrameType.Data:
         case FrameType.WindowUpdate:
-          return await this.handleStreamMessage(header, readData)
+        { await this.handleStreamMessage(header, readData); return }
         default:
           // Invalid state
           throw errcode(new Error('Invalid frame type'), ERR_INVALID_FRAME, { header })
@@ -452,14 +452,14 @@ export class YamuxMuxer implements StreamMuxer {
 
     switch (type) {
       case FrameType.WindowUpdate: {
-        return stream.handleWindowUpdate(header)
+        stream.handleWindowUpdate(header); return
       }
       case FrameType.Data: {
         if (readData === undefined) {
           throw new Error('unreachable')
         }
 
-        return await stream.handleData(header, readData)
+        await stream.handleData(header, readData); return
       }
       default:
         throw new Error('unreachable')
@@ -478,23 +478,23 @@ export class YamuxMuxer implements StreamMuxer {
 
     if (this.localGoAway !== undefined) {
       // reject (reset) immediately if we are doing a go away
-      return this.sendFrame({
+      this.sendFrame({
         type: FrameType.WindowUpdate,
         flag: Flag.RST,
         streamID: id,
         length: 0
-      })
+      }); return
     }
 
     // check against our configured maximum number of inbound streams
     if (this.numInboundStreams >= this.config.maxInboundStreams) {
       this.log?.('maxIncomingStreams exceeded, forcing stream reset')
-      return this.sendFrame({
+      this.sendFrame({
         type: FrameType.WindowUpdate,
         flag: Flag.RST,
         streamID: id,
         length: 0
-      })
+      }); return
     }
 
     // allocate a new stream
@@ -528,7 +528,7 @@ export class YamuxMuxer implements StreamMuxer {
     }
     this.sendFrame({
       type: FrameType.Ping,
-      flag: flag,
+      flag,
       streamID: 0,
       length: pingId
     })

src/stream.ts

@@ -49,11 +49,11 @@ export class YamuxStream implements Stream {
   writeState: HalfStreamState
 
   /** Input to the read side of the stream */
-  sourceInput: Pushable<Uint8ArrayList>;
+  sourceInput: Pushable<Uint8ArrayList>
   /** Read side of the stream */
-  source: Source<Uint8ArrayList>;
+  source: Source<Uint8ArrayList>
   /** Write side of the stream */
-  sink: Sink<Uint8Array | Uint8ArrayList>;
+  sink: Sink<Uint8Array | Uint8ArrayList>
 
   private readonly config: Config
   private readonly log?: Logger
@@ -149,14 +149,14 @@ export class YamuxStream implements Stream {
     }
   }
 
-  private async * createSource () {
+  private async * createSource (): AsyncGenerator<Uint8ArrayList> {
     try {
       for await (const val of this.sourceInput) {
         this.sendWindowUpdate()
         yield val
       }
     } catch (err) {
-      const errCode = (err as {code: string}).code
+      const errCode = (err as { code: string }).code
       if (errCode !== ERR_STREAM_ABORT && errCode !== ERR_STREAM_RESET) {
         this.log?.error('stream source error id=%s', this._id, err)
         throw err
@@ -282,11 +282,11 @@ export class YamuxStream implements Stream {
       return
     }
     let reject: (err: Error) => void
-    const abort = () => {
+    const abort = (): void => {
       reject(errcode(new Error('stream aborted'), ERR_STREAM_ABORT))
     }
     this.abortController.signal.addEventListener('abort', abort)
-    return await new Promise((_resolve, _reject) => {
+    await new Promise((_resolve, _reject) => {
       this.sendWindowCapacityUpdate = () => {
         this.abortController.signal.removeEventListener('abort', abort)
         _resolve(undefined)

test/bench/comparison.bench.ts

@@ -23,7 +23,7 @@ describe('comparison benchmark', () => {
         id: `${name} send and receive ${numMessages} ${msgSize / 1024}KB chunks`,
         beforeEach: () => impl({
           onIncomingStream: (stream) => {
-            void pipe(stream, drain).then(() => stream.close())
+            void pipe(stream, drain).then(() => { stream.close() })
           }
         }),
         fn: async ({ client, server }) => {

test/codec.spec.ts

@@ -5,7 +5,7 @@ import { encodeHeader } from '../src/encode.js'
 import { Flag, FrameHeader, FrameType, GoAwayCode, stringifyHeader } from '../src/frame.js'
 import { decodeHeaderNaive, encodeHeaderNaive } from './codec.util.js'
 
-const frames: Array<{header: FrameHeader, data?: Uint8Array}> = [
+const frames: Array<{ header: FrameHeader, data?: Uint8Array }> = [
   { header: { type: FrameType.Ping, flag: Flag.SYN, streamID: 0, length: 1 } },
   { header: { type: FrameType.WindowUpdate, flag: Flag.SYN, streamID: 1, length: 1 } },
   { header: { type: FrameType.GoAway, flag: 0, streamID: 0, length: GoAwayCode.NormalTermination } },

test/decode.spec.ts

@@ -9,7 +9,7 @@ import { timeout } from './util.js'
 import { ERR_DECODE_IN_PROGRESS } from '../src/constants.js'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
-const frames: Array<{header: FrameHeader, data?: Uint8Array}> = [
+const frames: Array<{ header: FrameHeader, data?: Uint8Array }> = [
   { header: { type: FrameType.Ping, flag: Flag.SYN, streamID: 0, length: 1 } },
   { header: { type: FrameType.WindowUpdate, flag: Flag.SYN, streamID: 1, length: 1 } },
   { header: { type: FrameType.GoAway, flag: 0, streamID: 0, length: GoAwayCode.NormalTermination } },
@@ -18,13 +18,13 @@ const frames: Array<{header: FrameHeader, data?: Uint8Array}> = [
   { header: { type: FrameType.GoAway, flag: 0, streamID: 0, length: GoAwayCode.ProtocolError } }
 ]
 
-const data = (length: number) => Uint8Array.from(Array.from({ length }), (_, i) => i)
+const data = (length: number): Uint8Array => Uint8Array.from(Array.from({ length }), (_, i) => i)
 
-const expectEqualBytes = (actual: Uint8Array | Uint8ArrayList, expected: Uint8Array | Uint8ArrayList, reason?: string) => {
+const expectEqualBytes = (actual: Uint8Array | Uint8ArrayList, expected: Uint8Array | Uint8ArrayList, reason?: string): void => {
   expect(actual instanceof Uint8Array ? actual : actual.subarray(), reason).to.deep.equal(expected instanceof Uint8Array ? expected : expected.subarray())
 }
 
-const expectEqualDataFrame = (actual: {header: FrameHeader, data?: Uint8Array | Uint8ArrayList}, expected: {header: FrameHeader, data?: Uint8Array | Uint8ArrayList}, reason = '') => {
+const expectEqualDataFrame = (actual: { header: FrameHeader, data?: Uint8Array | Uint8ArrayList }, expected: { header: FrameHeader, data?: Uint8Array | Uint8ArrayList }, reason = ''): void => {
   expect(actual.header, reason + ' header').to.deep.equal(expected.header)
   if (actual.data == null && expected.data != null) {
     expect.fail('actual has no data but expected does')
@@ -37,7 +37,7 @@ const expectEqualDataFrame = (actual: {header: FrameHeader, data?: Uint8Array |
   }
 }
 
-const expectEqualDataFrames = (actual: Array<{header: FrameHeader, data?: Uint8Array | Uint8ArrayList}>, expected: Array<{header: FrameHeader, data?: Uint8Array | Uint8ArrayList}>) => {
+const expectEqualDataFrames = (actual: Array<{ header: FrameHeader, data?: Uint8Array | Uint8ArrayList }>, expected: Array<{ header: FrameHeader, data?: Uint8Array | Uint8ArrayList }>): void => {
   if (actual.length !== expected.length) {
     expect.fail('actual')
   }
@@ -46,12 +46,12 @@ const expectEqualDataFrames = (actual: Array<{header: FrameHeader, data?: Uint8A
   }
 }
 
-const dataFrame = (length: number) => ({
+const dataFrame = (length: number): { header: FrameHeader, data: Uint8Array } => ({
   header: { type: FrameType.Data, flag: 0, streamID: 1, length },
   data: data(length)
 })
 
-export const randomRanges = (length: number) => {
+export const randomRanges = (length: number): number[][] => {
   const indices = []
   let i = 0
   let j = 0
@@ -345,7 +345,7 @@ describe('Decoder', () => {
         }
         expect.fail('decoding another frame before the first is finished should error')
       } catch (e) {
-        expect((e as {code: string}).code).to.equal(ERR_DECODE_IN_PROGRESS)
+        expect((e as { code: string }).code).to.equal(ERR_DECODE_IN_PROGRESS)
       }
     })
   })

test/mplex.util.ts

@@ -6,7 +6,7 @@ import type { StreamMuxer, StreamMuxerInit } from '@libp2p/interface-stream-muxe
 
 const factory = mplex()()
 
-export function testYamuxMuxer (name: string, client: boolean, conf: StreamMuxerInit = {}) {
+export function testYamuxMuxer (name: string, client: boolean, conf: StreamMuxerInit = {}): StreamMuxer {
   return factory.createStreamMuxer({
     ...conf,
     direction: client ? 'outbound' : 'inbound'
@@ -16,13 +16,13 @@ export function testYamuxMuxer (name: string, client: boolean, conf: StreamMuxer
 /**
  * Create a transform that can be paused and unpaused
  */
-export function pauseableTransform <A> (): {transform: Transform<A, A>, pause: () => void, unpause: () => void} {
+export function pauseableTransform <A> (): { transform: Transform<A, A>, pause: () => void, unpause: () => void } {
   let resolvePausePromise: ((value: unknown) => void) | undefined
   let pausePromise: Promise<unknown> | undefined
-  const unpause = () => {
+  const unpause = (): void => {
     resolvePausePromise?.(null)
   }
-  const pause = () => {
+  const pause = (): void => {
     pausePromise = new Promise(resolve => {
       resolvePausePromise = resolve
     })
@@ -81,10 +81,10 @@ export function testClientServer (conf: StreamMuxerInit = {}): {
   }
 }
 
-export async function timeout (ms: number) {
-  return await new Promise((_resolve, reject) => setTimeout(() => reject(new Error(`timeout after ${ms}ms`)), ms))
+export async function timeout (ms: number): Promise<unknown> {
+  return await new Promise((_resolve, reject) => setTimeout(() => { reject(new Error(`timeout after ${ms}ms`)) }, ms))
 }
 
-export async function sleep (ms: number) {
-  return await new Promise(resolve => setTimeout(() => resolve(ms), ms))
+export async function sleep (ms: number): Promise<unknown> {
+  return await new Promise(resolve => setTimeout(() => { resolve(ms) }, ms))
 }

test/muxer.spec.ts

@@ -94,7 +94,7 @@ describe('muxer', () => {
       client.newStream()
       expect.fail('should not be able to open a stream after close')
     } catch (e) {
-      expect((e as {code: string}).code).to.equal(ERR_MUXER_LOCAL_CLOSED)
+      expect((e as { code: string }).code).to.equal(ERR_MUXER_LOCAL_CLOSED)
     }
   })
 

test/stream.spec.ts

@@ -211,7 +211,7 @@ describe('stream', () => {
     try {
       await Promise.all([sendPipe, recvPipe])
     } catch (e) {
-      expect((e as {code: string}).code).to.equal(ERR_STREAM_RESET)
+      expect((e as { code: string }).code).to.equal(ERR_STREAM_RESET)
     }
     // eslint-disable-next-line @typescript-eslint/dot-notation
     expect(client['remoteGoAway']).to.equal(GoAwayCode.ProtocolError)

test/util.ts

@@ -32,7 +32,7 @@ export class TestYamux extends Yamux {
   }
 }
 
-export function testYamuxMuxer (name: string, client: boolean, conf: YamuxMuxerInit = {}) {
+export function testYamuxMuxer (name: string, client: boolean, conf: YamuxMuxerInit = {}): YamuxMuxer {
   return new YamuxMuxer({
     ...testConf,
     ...conf,
@@ -44,13 +44,13 @@ export function testYamuxMuxer (name: string, client: boolean, conf: YamuxMuxerI
 /**
  * Create a transform that can be paused and unpaused
  */
-export function pauseableTransform <A> (): {transform: Transform<A, A>, pause: () => void, unpause: () => void} {
+export function pauseableTransform <A> (): { transform: Transform<A, A>, pause: () => void, unpause: () => void } {
   let resolvePausePromise: ((value: unknown) => void) | undefined
   let pausePromise: Promise<unknown> | undefined
-  const unpause = () => {
+  const unpause = (): void => {
     resolvePausePromise?.(null)
   }
-  const pause = () => {
+  const pause = (): void => {
     pausePromise = new Promise(resolve => {
       resolvePausePromise = resolve
     })
@@ -109,10 +109,10 @@ export function testClientServer (conf: YamuxMuxerInit = {}): {
   }
 }
 
-export async function timeout (ms: number) {
-  return await new Promise((_resolve, reject) => setTimeout(() => reject(new Error(`timeout after ${ms}ms`)), ms))
+export async function timeout (ms: number): Promise<unknown> {
+  return await new Promise((_resolve, reject) => setTimeout(() => { reject(new Error(`timeout after ${ms}ms`)) }, ms))
 }
 
-export async function sleep (ms: number) {
-  return await new Promise(resolve => setTimeout(() => resolve(ms), ms))
+export async function sleep (ms: number): Promise<unknown> {
+  return await new Promise(resolve => setTimeout(() => { resolve(ms) }, ms))
 }