@libp2p/utils 6.7.1 → 6.7.2-8484de8a2

package/src/close.ts

@@ -1,65 +0,0 @@
-import type { Connection, Stream, AbortOptions } from '@libp2p/interface'
-
-/**
- * Close the passed stream, falling back to aborting the stream if closing
- * cleanly fails.
- */
-export async function safelyCloseStream (stream?: Stream, options?: AbortOptions): Promise<void> {
-  try {
-    await stream?.close(options)
-  } catch (err: any) {
-    stream?.abort(err)
-  }
-}
-
-/**
- * These are speculative protocols that are run automatically on connection open
- * so are usually not the reason the connection was opened.
- *
- * Consequently when requested it should be safe to close connections that only
- * have these protocol streams open.
- */
-const DEFAULT_CLOSABLE_PROTOCOLS = [
-  // identify
-  '/ipfs/id/1.0.0',
-
-  // identify-push
-  '/ipfs/id/push/1.0.0',
-
-  // autonat
-  '/libp2p/autonat/1.0.0',
-
-  // dcutr
-  '/libp2p/dcutr'
-]
-
-export interface SafelyCloseConnectionOptions extends AbortOptions {
-  /**
-   * Only close the stream if it either has no protocol streams open or only
-   * ones in this list.
-   *
-   * @default ['/ipfs/id/1.0.0']
-   */
-  closableProtocols?: string[]
-}
-
-/**
- * Close the passed connection if it has no streams, or only closable protocol
- * streams, falling back to aborting the connection if closing it cleanly fails.
- */
-export async function safelyCloseConnectionIfUnused (connection?: Connection, options?: SafelyCloseConnectionOptions): Promise<void> {
-  const streamProtocols = connection?.streams?.map(stream => stream.protocol) ?? []
-  const closableProtocols = options?.closableProtocols ?? DEFAULT_CLOSABLE_PROTOCOLS
-
-  // if the connection has protocols not in the closable protocols list, do not
-  // close the connection
-  if (streamProtocols.filter(proto => proto != null && !closableProtocols.includes(proto)).length > 0) {
-    return
-  }
-
-  try {
-    await connection?.close(options)
-  } catch (err: any) {
-    connection?.abort(err)
-  }
-}

package/src/multiaddr/is-ip-based.ts

@@ -1,21 +0,0 @@
-import { CODE_IP4, CODE_IP6, CODE_IP6ZONE } from '@multiformats/multiaddr'
-import type { Multiaddr } from '@multiformats/multiaddr'
-
-/**
- * Check if a given multiaddr is IP-based
- */
-export function isIpBased (ma: Multiaddr): boolean {
-  try {
-    for (const { code } of ma.getComponents()) {
-      if (code === CODE_IP6ZONE) {
-        continue
-      }
-
-      return code === CODE_IP4 || code === CODE_IP6
-    }
-  } catch {
-
-  }
-
-  return false
-}

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

@@ -1,105 +0,0 @@
-import forEach from 'it-foreach'
-import { pipe } from 'it-pipe'
-import type { ComponentLogger, MultiaddrConnection, Stream } from '@libp2p/interface'
-import type { Multiaddr } from '@multiformats/multiaddr'
-import type { Uint8ArrayList } from 'uint8arraylist'
-
-export interface StreamProperties {
-  stream: Stream
-  remoteAddr: Multiaddr
-  localAddr: Multiaddr
-  logger: ComponentLogger
-
-  /**
-   * A callback invoked when data is read from the stream
-   */
-  onDataRead?(buf: Uint8ArrayList | Uint8Array): void
-
-  /**
-   * A callback invoked when data is written to the stream
-   */
-  onDataWrite?(buf: Uint8ArrayList | Uint8Array): void
-}
-
-/**
- * Convert a duplex iterable into a MultiaddrConnection.
- * https://github.com/libp2p/interface-transport#multiaddrconnection
- */
-export function streamToMaConnection (props: StreamProperties): MultiaddrConnection {
-  const { stream, remoteAddr, logger, onDataRead, onDataWrite } = props
-  const log = logger.forComponent('libp2p:stream:converter')
-
-  let closedRead = false
-  let closedWrite = false
-
-  // piggyback on `stream.close` invocations to close multiaddr connection
-  const streamClose = stream.close.bind(stream)
-  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): void => {
-    streamAbort(err)
-    close(true)
-  }
-
-  // piggyback on `stream.sink` invocations to close multiaddr connection
-  const streamSink = stream.sink.bind(stream)
-  stream.sink = async (source): Promise<void> => {
-    try {
-      await streamSink(
-        pipe(
-          source,
-          (source) => forEach(source, buf => onDataWrite?.(buf))
-        )
-      )
-    } catch (err: any) {
-      // If aborted we can safely ignore
-      if (err.type !== 'aborted') {
-        // If the source errored the socket will already have been destroyed by
-        // toIterable.duplex(). If the socket errored it will already be
-        // destroyed. There's nothing to do here except log the error & return.
-        log.error('%s error in sink', remoteAddr, err)
-      }
-    } finally {
-      closedWrite = true
-      close()
-    }
-  }
-
-  const maConn: MultiaddrConnection = {
-    log,
-    sink: stream.sink,
-    source: (async function * (): AsyncGenerator<Uint8ArrayList> {
-      try {
-        for await (const buf of stream.source) {
-          onDataRead?.(buf)
-          yield buf
-        }
-      } finally {
-        closedRead = true
-        close()
-      }
-    }()),
-    remoteAddr,
-    timeline: { open: Date.now(), close: undefined },
-    close: stream.close,
-    abort: stream.abort
-  }
-
-  function close (force?: boolean): void {
-    if (force === true) {
-      closedRead = true
-      closedWrite = true
-    }
-
-    if (closedRead && closedWrite && maConn.timeline.close == null) {
-      maConn.timeline.close = Date.now()
-    }
-  }
-
-  return maConn
-}