Merge branch 'main' into fix/allow-overriding-mss-mode

Author: achingbrain

interop/firefox-version.json

@@ -2,10 +2,6 @@
   "id": "firefox-js-libp2p-head",
   "containerImageID": "firefox-js-libp2p-head",
   "transports": [
-    {
-      "name": "webtransport",
-      "onlyDial": true
-    },
     {
       "name": "webrtc-direct",
       "onlyDial": true

packages/metrics-opentelemetry/package.json

@@ -48,6 +48,7 @@
   },
   "dependencies": {
     "@libp2p/interface": "^2.4.0",
+    "@libp2p/utils": "^6.3.1",
     "@opentelemetry/api": "^1.9.0",
     "it-foreach": "^2.1.1",
     "it-stream-types": "^2.0.2"

packages/metrics-opentelemetry/src/index.ts

@@ -34,6 +34,9 @@
  */
 
 import { InvalidParametersError, serviceCapabilities } from '@libp2p/interface'
+import { isAsyncGenerator } from '@libp2p/utils/is-async-generator'
+import { isGenerator } from '@libp2p/utils/is-generator'
+import { isPromise } from '@libp2p/utils/is-promise'
 import { trace, metrics, context, SpanStatusCode } from '@opentelemetry/api'
 import each from 'it-foreach'
 import { OpenTelemetryCounterGroup } from './counter-group.js'
@@ -438,10 +441,6 @@ export function openTelemetryMetrics (init: OpenTelemetryMetricsInit = {}): (com
   return (components: OpenTelemetryComponents) => new OpenTelemetryMetrics(components, init)
 }
 
-function isPromise <T = any> (obj?: any): obj is Promise<T> {
-  return typeof obj?.then === 'function'
-}
-
 async function wrapPromise (promise: Promise<any>, span: Span, attributes: TraceAttributes, options?: TraceFunctionOptions<any, any>): Promise<any> {
   return promise
     .then(res => {
@@ -458,10 +457,6 @@ async function wrapPromise (promise: Promise<any>, span: Span, attributes: Trace
     })
 }
 
-function isGenerator (obj?: any): obj is Generator {
-  return obj?.[Symbol.iterator] != null
-}
-
 function wrapGenerator (gen: Generator, span: Span, attributes: TraceAttributes, options?: TraceGeneratorFunctionOptions<any, any, any>): Generator {
   const iter = gen[Symbol.iterator]()
   let index = 0
@@ -502,10 +497,6 @@ function wrapGenerator (gen: Generator, span: Span, attributes: TraceAttributes,
   return wrapped
 }
 
-function isAsyncGenerator (obj?: any): obj is AsyncGenerator {
-  return obj?.[Symbol.asyncIterator] != null
-}
-
 function wrapAsyncGenerator (gen: AsyncGenerator, span: Span, attributes: TraceAttributes, options?: TraceGeneratorFunctionOptions<any, any, any>): AsyncGenerator {
   const iter = gen[Symbol.asyncIterator]()
   let index = 0

packages/utils/package.json

@@ -84,6 +84,14 @@
       "types": "./dist/src/ip-port-to-multiaddr.d.ts",
       "import": "./dist/src/ip-port-to-multiaddr.js"
     },
+    "./is-async-generator": {
+      "types": "./dist/src/is-async-generator.d.ts",
+      "import": "./dist/src/is-async-generator.js"
+    },
+    "./is-generator": {
+      "types": "./dist/src/is-generator.d.ts",
+      "import": "./dist/src/is-generator.js"
+    },
     "./is-promise": {
       "types": "./dist/src/is-promise.d.ts",
       "import": "./dist/src/is-promise.js"

packages/utils/src/is-async-generator.ts

@@ -0,0 +1,16 @@
+export function isAsyncGenerator (obj: unknown): obj is AsyncGenerator {
+  if (obj == null) {
+    return false
+  }
+
+  const asyncIterator = (obj as { [Symbol.asyncIterator]?: unknown })?.[
+    Symbol.asyncIterator
+  ]
+
+  if (typeof asyncIterator !== 'function') {
+    return false
+  }
+
+  const instance = obj as { next?: unknown }
+  return typeof instance.next === 'function'
+}

packages/utils/src/is-generator.ts

@@ -0,0 +1,15 @@
+export function isGenerator (obj: unknown): obj is Generator {
+  if (obj == null) {
+    return false
+  }
+
+  const iterator = (obj as { [Symbol.iterator]?: unknown })?.[Symbol.iterator]
+
+  if (typeof iterator !== 'function') {
+    return false
+  }
+
+  const instance = obj as { next?: unknown }
+
+  return typeof instance.next === 'function'
+}

packages/utils/test/is-async-generator.spec.ts

@@ -0,0 +1,41 @@
+import { expect } from 'aegir/chai'
+import { isAsyncGenerator } from '../src/is-async-generator.js'
+
+describe('is-async-generator', () => {
+  it('should return true if the value is an async generator', () => {
+    async function * asyncGen (): AsyncGenerator<number> {
+      yield 1
+    }
+    const asyncGenerator = asyncGen()
+    expect(isAsyncGenerator(asyncGenerator)).to.be.true()
+
+    const asyncGenObj = (async function * () {
+      yield 1
+    })()
+    expect(isAsyncGenerator(asyncGenObj)).to.be.true()
+  })
+
+  it('should return false if the value is not an async generator', () => {
+    expect(isAsyncGenerator(1)).to.be.false()
+    expect(isAsyncGenerator('string')).to.be.false()
+    expect(isAsyncGenerator({})).to.be.false()
+    expect(isAsyncGenerator([])).to.be.false()
+    expect(isAsyncGenerator(null)).to.be.false()
+    expect(isAsyncGenerator(undefined)).to.be.false()
+    expect(isAsyncGenerator(() => {})).to.be.false()
+    expect(isAsyncGenerator(async () => {})).to.be.false()
+    expect(
+      isAsyncGenerator(function * () {
+        yield 1
+      })
+    ).to.be.false()
+    expect(
+      isAsyncGenerator(async function * () {
+        yield 1
+      })
+    ).to.be.false() // async generator function, not generator
+    expect(isAsyncGenerator(Promise.resolve())).to.be.false()
+    expect(isAsyncGenerator({ next: async () => {} })).to.be.false()
+    expect(isAsyncGenerator({ [Symbol.asyncIterator]: () => {} })).to.be.false()
+  })
+})

packages/utils/test/is-generator.spec.ts

@@ -0,0 +1,41 @@
+import { expect } from 'aegir/chai'
+import { isGenerator } from '../src/is-generator.js'
+
+describe('is-generator', () => {
+  it('should return true if the value is a generator', () => {
+    function * gen (): Generator<number> {
+      yield 1
+    }
+    const generator = gen()
+    expect(isGenerator(generator)).to.be.true()
+
+    const genObj = (function * () {
+      yield 1
+    })()
+    expect(isGenerator(genObj)).to.be.true()
+  })
+
+  it('should return false if the value is not a generator', () => {
+    expect(isGenerator(1)).to.be.false()
+    expect(isGenerator('string')).to.be.false()
+    expect(isGenerator({})).to.be.false()
+    expect(isGenerator([])).to.be.false()
+    expect(isGenerator(null)).to.be.false()
+    expect(isGenerator(undefined)).to.be.false()
+    expect(isGenerator(() => {})).to.be.false()
+    expect(isGenerator(async () => {})).to.be.false()
+    expect(
+      isGenerator(function * () {
+        yield 1
+      })
+    ).to.be.false() // generator function, not generator
+    expect(
+      isGenerator(async function * () {
+        yield 1
+      })
+    ).to.be.false()
+    expect(isGenerator(Promise.resolve())).to.be.false()
+    expect(isGenerator({ next: () => {} })).to.be.false()
+    expect(isGenerator({ [Symbol.iterator]: () => {} })).to.be.false()
+  })
+})

packages/utils/test/is-promise.spec.ts

@@ -31,4 +31,32 @@ describe('is-promise', () => {
   it('should not detect partial promise', () => {
     expect(isPromise({ then: true })).to.be.false()
   })
+
+  it('should return true if the value is a promise', () => {
+    expect(isPromise(Promise.resolve())).to.be.true()
+    expect(isPromise(new Promise(() => {}))).to.be.true()
+    expect(isPromise(Promise.reject(new Error('test')))).to.be.true()
+  })
+
+  it('should return false if the value is not a promise', () => {
+    expect(isPromise(1)).to.be.false()
+    expect(isPromise('string')).to.be.false()
+    expect(isPromise({})).to.be.false()
+    expect(isPromise([])).to.be.false()
+    expect(isPromise(null)).to.be.false()
+    expect(isPromise(undefined)).to.be.false()
+    expect(isPromise(() => {})).to.be.false()
+    expect(isPromise(async () => {})).to.be.false()
+    expect(
+      isPromise(function * () {
+        yield 1
+      })
+    ).to.be.false()
+    expect(
+      isPromise(async function * () {
+        yield 1
+      })
+    ).to.be.false()
+    expect(isPromise({ then: 1 })).to.be.false()
+  })
 })

packages/utils/typedoc.json

@@ -11,6 +11,8 @@
     "./src/filters/index.ts",
     "./src/global-unicast-ip.ts",
     "./src/ip-port-to-multiaddr.ts",
+    "./src/is-async-generator.ts",
+    "./src/is-generator.ts",
     "./src/is-promise.ts",
     "./src/link-local-ip.ts",
     "./src/moving-average.ts",