@libp2p/utils 6.6.3 → 6.6.4

package/src/merge-options.ts

@@ -0,0 +1,161 @@
+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/private-ip.ts

@@ -32,7 +32,7 @@ const NETMASK_RANGES = PRIVATE_IP_RANGES.map(ipRange => new Netmask(ipRange))
 
 function ipv4Check (ipAddr: string): boolean {
   for (const r of NETMASK_RANGES) {
-    if (r.contains(ipAddr)) return true
+    if (r.contains(ipAddr)) { return true }
   }
 
   return false
@@ -89,9 +89,5 @@ function ipv6Check (ipAddr: string): boolean {
 }
 
 export function isPrivateIp (ip: string): boolean | undefined {
-  if (isIPv4(ip)) return ipv4Check(ip)
-  else if (isIpv4MappedIpv6(ip)) return ipv4MappedIpv6Check(ip)
-  else if (isIpv4EmbeddedIpv6(ip)) return ipv4EmbeddedIpv6Check(ip)
-  else if (isIPv6(ip)) return ipv6Check(ip)
-  else return undefined
+  if (isIPv4(ip)) { return ipv4Check(ip) } else if (isIpv4MappedIpv6(ip)) { return ipv4MappedIpv6Check(ip) } else if (isIpv4EmbeddedIpv6(ip)) { return ipv4EmbeddedIpv6Check(ip) } else if (isIPv6(ip)) { return ipv6Check(ip) } else { return undefined }
 }

package/src/queue/index.ts

@@ -71,49 +71,49 @@ export interface QueueEvents<JobReturnType, JobOptions extends AbortOptions = Ab
   /**
    * A job is about to start running
    */
-  'active': CustomEvent
+  active: CustomEvent
 
   /**
    * All jobs have finished and the queue is empty
    */
-  'idle': CustomEvent
+  idle: CustomEvent
 
   /**
    * The queue is empty, jobs may be running
    */
-  'empty': CustomEvent
+  empty: CustomEvent
 
   /**
    * A job was added to the queue
    */
-  'add': CustomEvent
+  add: CustomEvent
 
   /**
    * A job has finished or failed
    */
-  'next': CustomEvent
+  next: CustomEvent
 
   /**
    * A job has finished successfully
    */
-  'completed': CustomEvent<JobReturnType>
+  completed: CustomEvent<JobReturnType>
 
   /**
    * A job has failed
    */
-  'error': CustomEvent<Error>
+  error: CustomEvent<Error>
 
   /**
    * Emitted just after `"completed", a job has finished successfully - this
    * event gives access to the job and it's result
    */
-  'success': CustomEvent<QueueJobSuccess<JobReturnType, JobOptions>>
+  success: CustomEvent<QueueJobSuccess<JobReturnType, JobOptions>>
 
   /**
    * Emitted just after `"error", a job has failed - this event gives access to
    * the job and the thrown error
    */
-  'failure': CustomEvent<QueueJobFailure<JobReturnType, JobOptions>>
+  failure: CustomEvent<QueueJobFailure<JobReturnType, JobOptions>>
 }
 
 /**

package/src/repeating-task.ts

@@ -18,7 +18,7 @@ export interface RepeatingTask {
    * Update the amount of time a task will run before the passed abort signal
    * will fire.
    *
-   * * This only affects the next iteration of the task, if it is currently
+   * This only affects the next iteration of the task, if it is currently
    * running, that run will not be interrupted.
    */
   setTimeout(ms: number): void
@@ -83,7 +83,7 @@ export function repeatingTask (fn: (options?: AbortOptions) => void | Promise<vo
   let started = false
 
   return {
-    setInterval: (ms) => {
+    setInterval: (ms): void => {
       interval = ms
 
       // maybe reschedule
@@ -92,14 +92,11 @@ export function repeatingTask (fn: (options?: AbortOptions) => void | Promise<vo
         timeout = setTimeout(runTask, interval)
       }
     },
-    setTimeout: (ms) => {
-      if (options == null) {
-        options = {}
-      }
-
+    setTimeout: (ms): void => {
+      options ??= {}
       options.timeout = ms
     },
-    start: () => {
+    start: (): void => {
       if (started) {
         return
       }
@@ -118,7 +115,7 @@ export function repeatingTask (fn: (options?: AbortOptions) => void | Promise<vo
         timeout = setTimeout(runTask, interval)
       }
     },
-    stop: () => {
+    stop: (): void => {
       clearTimeout(timeout)
       shutdownController?.abort()
       started = false

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

@@ -34,21 +34,21 @@ export function streamToMaConnection (props: StreamProperties): MultiaddrConnect
 
   // piggyback on `stream.close` invocations to close multiaddr connection
   const streamClose = stream.close.bind(stream)
-  stream.close = async (options) => {
+  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) => {
+  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) => {
+  stream.sink = async (source): Promise<void> => {
     try {
       await streamSink(
         pipe(
@@ -73,7 +73,7 @@ export function streamToMaConnection (props: StreamProperties): MultiaddrConnect
   const maConn: MultiaddrConnection = {
     log,
     sink: stream.sink,
-    source: (async function * () {
+    source: (async function * (): AsyncGenerator<Uint8ArrayList> {
       try {
         for await (const buf of stream.source) {
           onDataRead?.(buf)