@libp2p/utils 6.7.2-f5932c294 → 6.7.2-fb19b055d

package/src/merge-options.ts

@@ -1,161 +0,0 @@
-import isOptionObject from 'is-plain-obj'
-
-const { hasOwnProperty } = Object.prototype
-const { propertyIsEnumerable } = Object
-const defineProperty = (object: any, name: any, value: any): void => {
-  Object.defineProperty(object, name, {
-    value,
-    writable: true,
-    enumerable: true,
-    configurable: true
-  })
-}
-
-const globalThis = this
-const defaultMergeOptions = {
-  concatArrays: false,
-  ignoreUndefined: false
-}
-
-const getEnumerableOwnPropertyKeys = (value: any): any[] => {
-  const keys = []
-
-  for (const key in value) {
-    if (hasOwnProperty.call(value, key)) {
-      keys.push(key)
-    }
-  }
-
-  /* istanbul ignore else  */
-  if (Object.getOwnPropertySymbols) {
-    const symbols = Object.getOwnPropertySymbols(value)
-
-    for (const symbol of symbols) {
-      if (propertyIsEnumerable.call(value, symbol)) {
-        keys.push(symbol)
-      }
-    }
-  }
-
-  return keys
-}
-
-function clone <T> (value: T): T
-function clone <T> (value: T[]): T[]
-function clone (value: any): any {
-  if (Array.isArray(value)) {
-    return cloneArray(value)
-  }
-
-  if (isOptionObject(value)) {
-    return cloneOptionObject(value)
-  }
-
-  return value
-}
-
-function cloneArray <T> (array: T[]): T[] {
-  const result = array.slice(0, 0)
-
-  getEnumerableOwnPropertyKeys(array).forEach(key => {
-    defineProperty(result, key, clone(array[key]))
-  })
-
-  return result
-}
-
-function cloneOptionObject (object: any): any {
-  const result = Object.getPrototypeOf(object) === null ? Object.create(null) : {}
-
-  getEnumerableOwnPropertyKeys(object).forEach(key => {
-    defineProperty(result, key, clone(object[key]))
-  })
-
-  return result
-}
-
-const mergeKeys = (merged: any, source: any, keys: any[], config: any): any => {
-  keys.forEach(key => {
-    if (typeof source[key] === 'undefined' && config.ignoreUndefined) {
-      return
-    }
-
-    // Do not recurse into prototype chain of merged
-    if (key in merged && merged[key] !== Object.getPrototypeOf(merged)) {
-      defineProperty(merged, key, merge(merged[key], source[key], config))
-    } else {
-      defineProperty(merged, key, clone(source[key]))
-    }
-  })
-
-  return merged
-}
-
-/**
- * see [Array.prototype.concat ( ...arguments )](http://www.ecma-international.org/ecma-262/6.0/#sec-array.prototype.concat)
- */
-const concatArrays = (merged: any, source: any, config: any): any => {
-  let result = merged.slice(0, 0)
-  let resultIndex = 0;
-
-  [merged, source].forEach(array => {
-    const indices: any[] = []
-
-    // `result.concat(array)` with cloning
-    for (let k = 0; k < array.length; k++) {
-      if (!hasOwnProperty.call(array, k)) {
-        continue
-      }
-
-      indices.push(String(k))
-
-      if (array === merged) {
-        // Already cloned
-        defineProperty(result, resultIndex++, array[k])
-      } else {
-        defineProperty(result, resultIndex++, clone(array[k]))
-      }
-    }
-
-    // Merge non-index keys
-    result = mergeKeys(result, array, getEnumerableOwnPropertyKeys(array).filter(key => !indices.includes(key)), config)
-  })
-
-  return result
-}
-
-function merge (merged: any, source: any, config: any): any {
-  if (config.concatArrays && Array.isArray(merged) && Array.isArray(source)) {
-    return concatArrays(merged, source, config)
-  }
-
-  if (!isOptionObject(source) || !isOptionObject(merged)) {
-    return clone(source)
-  }
-
-  return mergeKeys(merged, source, getEnumerableOwnPropertyKeys(source), config)
-}
-
-/**
- * Port of `merge-options` to typescript
- *
- * @see https://github.com/schnittstabil/merge-options/pull/28
- */
-export function mergeOptions (this: any, ...options: any[]): any {
-  const config = merge(clone(defaultMergeOptions), (this !== globalThis && this) || {}, defaultMergeOptions)
-  let merged = { _: {} }
-
-  for (const option of options) {
-    if (option === undefined) {
-      continue
-    }
-
-    if (!isOptionObject(option)) {
-      throw new TypeError('`' + option + '` is not an Option Object')
-    }
-
-    merged = merge(merged, { _: option }, config)
-  }
-
-  return merged._
-}

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,106 +0,0 @@
-import forEach from 'it-foreach'
-import { pipe } from 'it-pipe'
-import type { Logger, 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
-  log: Logger
-
-  /**
-   * 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, log, onDataRead, onDataWrite } = props
-
-  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) {
-      maConn.log.error('errored - %e', err)
-
-      // 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.
-        maConn.log.error('%s error in sink - %e', remoteAddr, err)
-      }
-    } finally {
-      closedWrite = true
-      close()
-    }
-  }
-
-  const maConn: MultiaddrConnection = {
-    log: log.newScope('stream-to-maconn'),
-    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
-}