deps(dev): bump aegir from 38.1.8 to 39.0.10

package.json

@@ -159,7 +159,7 @@
   },
   "devDependencies": {
     "@types/varint": "^6.0.0",
-    "aegir": "^38.1.8",
+    "aegir": "^39.0.10",
     "iso-random-stream": "^2.0.2",
     "it-all": "^3.0.1",
     "it-map": "^3.0.2",

src/handle.ts

@@ -1,11 +1,11 @@
 import { logger } from '@libp2p/logger'
-import * as multistream from './multistream.js'
 import { handshake } from 'it-handshake'
-import { PROTOCOL_ID } from './constants.js'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { Uint8ArrayList } from 'uint8arraylist'
-import type { Duplex, Source } from 'it-stream-types'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { PROTOCOL_ID } from './constants.js'
+import * as multistream from './multistream.js'
 import type { ByteArrayInit, ByteListInit, MultistreamSelectInit, ProtocolStream } from './index.js'
+import type { Duplex, Source } from 'it-stream-types'
 
 const log = logger('libp2p:mss:handle')
 

src/index.ts

@@ -1,6 +1,6 @@
 import { PROTOCOL_ID } from './constants.js'
-import type { Duplex, Source } from 'it-stream-types'
 import type { AbortOptions } from '@libp2p/interfaces'
+import type { Duplex, Source } from 'it-stream-types'
 
 export { PROTOCOL_ID }
 

src/multistream.ts

@@ -1,19 +1,19 @@
 
-import { Uint8ArrayList } from 'uint8arraylist'
+import { CodeError } from '@libp2p/interfaces/errors'
+import { logger } from '@libp2p/logger'
+import { abortableSource } from 'abortable-iterator'
+import first from 'it-first'
 import * as lp from 'it-length-prefixed'
 import { pipe } from 'it-pipe'
-import { CodeError } from '@libp2p/interfaces/errors'
+import { Uint8ArrayList } from 'uint8arraylist'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import first from 'it-first'
-import { abortableSource } from 'abortable-iterator'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import type { Pushable } from 'it-pushable'
+import { MAX_PROTOCOL_LENGTH } from './constants.js'
+import type { MultistreamSelectInit } from '.'
 import type { AbortOptions } from '@libp2p/interfaces'
-import type { Source } from 'it-stream-types'
+import type { Pushable } from 'it-pushable'
 import type { Reader } from 'it-reader'
-import type { MultistreamSelectInit } from '.'
-import { MAX_PROTOCOL_LENGTH } from './constants.js'
-import { logger } from '@libp2p/logger'
+import type { Source } from 'it-stream-types'
 
 const log = logger('libp2p:mss')
 
@@ -59,7 +59,7 @@ export async function read (reader: Reader, options?: AbortOptions): Promise<Uin
   let byteLength = 1 // Read single byte chunks until the length is known
   const varByteSource = { // No return impl - we want the reader to remain readable
     [Symbol.asyncIterator]: () => varByteSource,
-    next: async () => await reader.next(byteLength)
+    next: async () => reader.next(byteLength)
   }
 
   let input: Source<Uint8ArrayList> = varByteSource
@@ -78,7 +78,7 @@ export async function read (reader: Reader, options?: AbortOptions): Promise<Uin
   const buf = await pipe(
     input,
     (source) => lp.decode(source, { onLength, maxDataLength: MAX_PROTOCOL_LENGTH }),
-    async (source) => await first(source)
+    async (source) => first(source)
   )
 
   if (buf == null || buf.length === 0) {

src/select.ts

@@ -1,15 +1,15 @@
-import { logger } from '@libp2p/logger'
 import { CodeError } from '@libp2p/interfaces/errors'
-import * as multistream from './multistream.js'
+import { logger } from '@libp2p/logger'
 import { handshake } from 'it-handshake'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { PROTOCOL_ID } from './index.js'
-import type { Duplex, Source } from 'it-stream-types'
-import { Uint8ArrayList } from 'uint8arraylist'
-import { pushable } from 'it-pushable'
 import merge from 'it-merge'
+import { pushable } from 'it-pushable'
 import { reader } from 'it-reader'
+import { Uint8ArrayList } from 'uint8arraylist'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import * as multistream from './multistream.js'
+import { PROTOCOL_ID } from './index.js'
 import type { ByteArrayInit, ByteListInit, MultistreamSelectInit, ProtocolStream } from './index.js'
+import type { Duplex, Source } from 'it-stream-types'
 
 const log = logger('libp2p:mss:select')
 

test/dialer.spec.ts

@@ -2,16 +2,16 @@
 /* eslint max-nested-callbacks: ["error", 5] */
 
 import { expect } from 'aegir/chai'
-import { pipe } from 'it-pipe'
+import randomBytes from 'iso-random-stream/src/random.js'
 import all from 'it-all'
-import { Uint8ArrayList } from 'uint8arraylist'
 import { pair } from 'it-pair'
+import { pipe } from 'it-pipe'
 import { reader } from 'it-reader'
 import pTimeout from 'p-timeout'
-import randomBytes from 'iso-random-stream/src/random.js'
-import * as Multistream from '../src/multistream.js'
-import * as mss from '../src/index.js'
+import { Uint8ArrayList } from 'uint8arraylist'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import * as mss from '../src/index.js'
+import * as Multistream from '../src/multistream.js'
 
 describe('Dialer', () => {
   describe('dialer.select', () => {
@@ -26,7 +26,7 @@ describe('Dialer', () => {
 
       // Ensure stream is usable after selection
       const input = [randomBytes(10), randomBytes(64), randomBytes(3)]
-      const output = await pipe(input, selection.stream, async (source) => await all(source))
+      const output = await pipe(input, selection.stream, async (source) => all(source))
       expect(new Uint8ArrayList(...output).slice()).to.eql(new Uint8ArrayList(...input).slice())
     })
 
@@ -90,7 +90,7 @@ describe('Dialer', () => {
 
       // Ensure stream is usable after selection
       const input = [new Uint8ArrayList(randomBytes(10), randomBytes(64), randomBytes(3))]
-      const output = await pipe(input, selection.stream, async (source) => await all(source))
+      const output = await pipe(input, selection.stream, async (source) => all(source))
       expect(new Uint8ArrayList(...output).slice()).to.eql(new Uint8ArrayList(...input).slice())
     })
 
@@ -132,7 +132,7 @@ describe('Dialer', () => {
 
       // Ensure stream is usable after selection
       const input = [randomBytes(10), randomBytes(64), randomBytes(3)]
-      const output = await pipe(input, selection.stream, async (source) => await all(source))
+      const output = await pipe(input, selection.stream, async (source) => all(source))
       expect(new Uint8ArrayList(...output).slice()).to.eql(new Uint8ArrayList(...input).slice())
     })
   })

test/integration.spec.ts

@@ -1,12 +1,12 @@
 /* eslint-env mocha */
 
 import { expect } from 'aegir/chai'
-import { pipe } from 'it-pipe'
+import randomBytes from 'iso-random-stream/src/random.js'
 import all from 'it-all'
+import { duplexPair } from 'it-pair/duplex'
+import { pipe } from 'it-pipe'
 import { Uint8ArrayList } from 'uint8arraylist'
-import randomBytes from 'iso-random-stream/src/random.js'
 import * as mss from '../src/index.js'
-import { duplexPair } from 'it-pair/duplex'
 
 describe('Dialer and Listener integration', () => {
   it('should handle and select', async () => {
@@ -25,7 +25,7 @@ describe('Dialer and Listener integration', () => {
     // Ensure stream is usable after selection
     const input = [new Uint8ArrayList(randomBytes(10), randomBytes(64), randomBytes(3))]
     const output = await Promise.all([
-      pipe(input, dialerSelection.stream, async (source) => await all(source)),
+      pipe(input, dialerSelection.stream, async (source) => all(source)),
       pipe(listenerSelection.stream, listenerSelection.stream)
     ])
     expect(new Uint8ArrayList(...output[0]).slice()).to.eql(new Uint8ArrayList(...input).slice())
@@ -38,7 +38,7 @@ describe('Dialer and Listener integration', () => {
 
     const [listenerSelection, dialerSelection] = await Promise.all([
       mss.handle(pair[1], selectedProtocol),
-      (async () => await mss.select(pair[0], selectedProtocol))()
+      (async () => mss.select(pair[0], selectedProtocol))()
     ])
 
     expect(dialerSelection.protocol).to.equal(selectedProtocol)
@@ -47,7 +47,7 @@ describe('Dialer and Listener integration', () => {
     // Ensure stream is usable after selection
     const input = [new Uint8ArrayList(randomBytes(10), randomBytes(64), randomBytes(3))]
     const output = await Promise.all([
-      pipe(input, dialerSelection.stream, async (source) => await all(source)),
+      pipe(input, dialerSelection.stream, async (source) => all(source)),
       pipe(listenerSelection.stream, listenerSelection.stream)
     ])
     expect(new Uint8ArrayList(...output[0]).slice()).to.eql(new Uint8ArrayList(...input).slice())
@@ -69,7 +69,7 @@ describe('Dialer and Listener integration', () => {
     // Ensure stream is usable after selection
     const input = [randomBytes(10), randomBytes(64), randomBytes(3)]
     const output = await Promise.all([
-      pipe(input, dialerSelection.stream, async (source) => await all(source)),
+      pipe(input, dialerSelection.stream, async (source) => all(source)),
       pipe(listenerSelection.stream, listenerSelection.stream)
     ])
     expect(new Uint8ArrayList(...output[0]).slice()).to.eql(new Uint8ArrayList(...input).slice())
@@ -85,7 +85,7 @@ describe('Dialer and Listener integration', () => {
     // Ensure stream is usable after selection
     const input = [new Uint8ArrayList(randomBytes(10), randomBytes(64), randomBytes(3))]
     // Since the stream is lazy, we need to write to it before handling
-    const dialerOutPromise = pipe(input, dialerSelection.stream, async source => await all(source))
+    const dialerOutPromise = pipe(input, dialerSelection.stream, async source => all(source))
 
     const listenerSelection = await mss.handle(pair[1], protocol)
     expect(listenerSelection.protocol).to.equal(protocol)
@@ -106,7 +106,7 @@ describe('Dialer and Listener integration', () => {
     // Ensure stream is usable after selection
     const input = [new Uint8ArrayList(randomBytes(10), randomBytes(64), randomBytes(3))]
     // Since the stream is lazy, we need to write to it before handling
-    const dialerResultPromise = pipe(input, dialerSelection.stream, async source => await all(source))
+    const dialerResultPromise = pipe(input, dialerSelection.stream, async source => all(source))
 
     // The error message from this varies depending on how much data got
     // written when the dialer receives the `na` response and closes the

test/listener.spec.ts

@@ -1,17 +1,17 @@
 /* eslint-env mocha */
 
 import { expect } from 'aegir/chai'
-import { pipe } from 'it-pipe'
-import { Uint8ArrayList } from 'uint8arraylist'
-import { reader } from 'it-reader'
+import randomBytes from 'iso-random-stream/src/random.js'
 import all from 'it-all'
 import * as Lp from 'it-length-prefixed'
-import * as Multistream from '../src/multistream.js'
-import randomBytes from 'iso-random-stream/src/random.js'
+import map from 'it-map'
+import { pipe } from 'it-pipe'
+import { reader } from 'it-reader'
+import { Uint8ArrayList } from 'uint8arraylist'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import * as mss from '../src/index.js'
-import map from 'it-map'
+import * as Multistream from '../src/multistream.js'
 import type { Duplex, Source } from 'it-stream-types'
 
 describe('Listener', () => {
@@ -123,7 +123,7 @@ describe('Listener', () => {
             (source) => Lp.decode(source),
             // Stringify and remove the newline
             (source) => map(source, (buf) => uint8ArrayToString(buf.subarray()).trim()),
-            async (source) => await all(source)
+            async (source) => all(source)
           )
 
           expect(lsProtocols).to.deep.equal(handledProtocols)

test/multistream.spec.ts

@@ -2,14 +2,14 @@
 /* eslint max-nested-callbacks: ["error", 6] */
 
 import { expect } from 'aegir/chai'
-import * as Varint from 'varint'
-import { Uint8ArrayList } from 'uint8arraylist'
+import all from 'it-all'
+import { pushable } from 'it-pushable'
 import { reader } from 'it-reader'
-import * as Multistream from '../src/multistream.js'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { Uint8ArrayList } from 'uint8arraylist'
 import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
-import { pushable } from 'it-pushable'
-import all from 'it-all'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import * as Varint from 'varint'
+import * as Multistream from '../src/multistream.js'
 
 describe('Multistream', () => {
   describe('Multistream.encode', () => {