@libp2p/peer-collections 5.2.9-7655e5200 → 5.2.9-81ebe4e47

package/src/list.ts

@@ -1,4 +1,3 @@
-import { peerIdFromString } from '@libp2p/peer-id'
 import { mapIterable } from './util.js'
 import type { PeerId } from '@libp2p/interface'
 
@@ -20,23 +19,23 @@ import type { PeerId } from '@libp2p/interface'
  * ```
  */
 export class PeerList {
-  private list: string[]
+  private list: PeerId[]
 
   constructor (list?: PeerList | Iterable<PeerId>) {
     this.list = []
 
     if (list != null) {
       for (const value of list) {
-        this.list.push(value.toString())
+        this.list.push(value)
       }
     }
   }
 
   [Symbol.iterator] (): IterableIterator<PeerId> {
-    return mapIterable<[number, string], PeerId>(
+    return mapIterable<[number, PeerId], PeerId>(
       this.list.entries(),
       (val) => {
-        return peerIdFromString(val[1])
+        return val[1]
       }
     )
   }
@@ -52,26 +51,24 @@ export class PeerList {
   }
 
   entries (): IterableIterator<[number, PeerId]> {
-    return mapIterable<[number, string], [number, PeerId]>(
+    return mapIterable<[number, PeerId], [number, PeerId]>(
       this.list.entries(),
       (val) => {
-        return [val[0], peerIdFromString(val[1])]
+        return [val[0], val[1]]
       }
     )
   }
 
   every (predicate: (peerId: PeerId, index: number, arr: PeerList) => boolean): boolean {
-    return this.list.every((str, index) => {
-      return predicate(peerIdFromString(str), index, this)
+    return this.list.every((peerId, index) => {
+      return predicate(peerId, index, this)
     })
   }
 
   filter (predicate: (peerId: PeerId, index: number, arr: PeerList) => boolean): PeerList {
     const output = new PeerList()
 
-    this.list.forEach((str, index) => {
-      const peerId = peerIdFromString(str)
-
+    this.list.forEach((peerId, index) => {
       if (predicate(peerId, index, this)) {
         output.push(peerId)
       }
@@ -81,68 +78,68 @@ export class PeerList {
   }
 
   find (predicate: (peerId: PeerId, index: number, arr: PeerList) => boolean): PeerId | undefined {
-    const str = this.list.find((str, index) => {
-      return predicate(peerIdFromString(str), index, this)
+    const peerId = this.list.find((peerId, index) => {
+      return predicate(peerId, index, this)
     })
 
-    if (str == null) {
+    if (peerId == null) {
       return undefined
     }
 
-    return peerIdFromString(str)
+    return peerId
   }
 
   findIndex (predicate: (peerId: PeerId, index: number, arr: PeerList) => boolean): number {
-    return this.list.findIndex((str, index) => {
-      return predicate(peerIdFromString(str), index, this)
+    return this.list.findIndex((peerId, index) => {
+      return predicate(peerId, index, this)
     })
   }
 
   forEach (predicate: (peerId: PeerId, index: number, arr: PeerList) => void): void {
-    this.list.forEach((str, index) => {
-      predicate(peerIdFromString(str), index, this)
+    this.list.forEach((peerId, index) => {
+      predicate(peerId, index, this)
     })
   }
 
   includes (peerId: PeerId): boolean {
-    return this.list.includes(peerId.toString())
+    return this.includes(peerId)
   }
 
   indexOf (peerId: PeerId): number {
-    return this.list.indexOf(peerId.toString())
+    return this.list.findIndex(id => id.equals(peerId))
   }
 
   pop (): PeerId | undefined {
-    const str = this.list.pop()
+    const peerId = this.list.pop()
 
-    if (str == null) {
+    if (peerId == null) {
       return undefined
     }
 
-    return peerIdFromString(str)
+    return peerId
   }
 
   push (...peerIds: PeerId[]): void {
     for (const peerId of peerIds) {
-      this.list.push(peerId.toString())
+      this.list.push(peerId)
     }
   }
 
   shift (): PeerId | undefined {
-    const str = this.list.shift()
+    const peerId = this.list.shift()
 
-    if (str == null) {
+    if (peerId == null) {
       return undefined
     }
 
-    return peerIdFromString(str)
+    return peerId
   }
 
   unshift (...peerIds: PeerId[]): number {
     let len = this.list.length
 
     for (let i = peerIds.length - 1; i > -1; i--) {
-      len = this.list.unshift(peerIds[i].toString())
+      len = this.list.unshift(peerIds[i])
     }
 
     return len

package/src/map.ts

@@ -1,4 +1,3 @@
-import { peerIdFromString } from '@libp2p/peer-id'
 import { mapIterable } from './util.js'
 import type { PeerId } from '@libp2p/interface'
 
@@ -20,14 +19,14 @@ import type { PeerId } from '@libp2p/interface'
  * ```
  */
 export class PeerMap <T> {
-  private readonly map: Map<string, T>
+  private readonly map: Map<string, { key: PeerId, value: T }>
 
   constructor (map?: PeerMap<T>) {
     this.map = new Map()
 
     if (map != null) {
       for (const [key, value] of map.entries()) {
-        this.map.set(key.toString(), value)
+        this.map.set(key.toString(), { key, value })
       }
     }
   }
@@ -45,22 +44,22 @@ export class PeerMap <T> {
   }
 
   entries (): IterableIterator<[PeerId, T]> {
-    return mapIterable<[string, T], [PeerId, T]>(
+    return mapIterable<[string, { key: PeerId, value: T }], [PeerId, T]>(
       this.map.entries(),
       (val) => {
-        return [peerIdFromString(val[0]), val[1]]
+        return [val[1].key, val[1].value]
       }
     )
   }
 
   forEach (fn: (value: T, key: PeerId, map: PeerMap<T>) => void): void {
     this.map.forEach((value, key) => {
-      fn(value, peerIdFromString(key), this)
+      fn(value.value, value.key, this)
     })
   }
 
   get (peer: PeerId): T | undefined {
-    return this.map.get(peer.toString())
+    return this.map.get(peer.toString())?.value
   }
 
   has (peer: PeerId): boolean {
@@ -68,20 +67,20 @@ export class PeerMap <T> {
   }
 
   set (peer: PeerId, value: T): void {
-    this.map.set(peer.toString(), value)
+    this.map.set(peer.toString(), { key: peer, value })
   }
 
   keys (): IterableIterator<PeerId> {
-    return mapIterable<string, PeerId>(
-      this.map.keys(),
+    return mapIterable<{ key: PeerId, value: T }, PeerId>(
+      this.map.values(),
       (val) => {
-        return peerIdFromString(val)
+        return val.key
       }
     )
   }
 
   values (): IterableIterator<T> {
-    return this.map.values()
+    return mapIterable(this.map.values(), (val) => val.value)
   }
 
   get size (): number {

package/src/set.ts

@@ -1,5 +1,4 @@
-import { peerIdFromString } from '@libp2p/peer-id'
-import { mapIterable } from './util.js'
+import { mapIterable, peerIdFromString } from './util.js'
 import type { PeerId } from '@libp2p/interface'
 
 /**
@@ -65,9 +64,9 @@ export class PeerSet {
 
   forEach (predicate: (peerId: PeerId, index: PeerId, set: PeerSet) => void): void {
     this.set.forEach((str) => {
-      const id = peerIdFromString(str)
+      const peerId = peerIdFromString(str)
 
-      predicate(id, id, this)
+      predicate(peerId, peerId, this)
     })
   }
 

package/src/util.ts

@@ -1,3 +1,8 @@
+import { peerIdFromMultihash } from '@libp2p/peer-id'
+import { base58btc } from 'multiformats/bases/base58'
+import * as Digest from 'multiformats/hashes/digest'
+import type { PeerId } from '@libp2p/interface'
+
 /**
  * Calls the passed map function on every entry of the passed iterable iterator
  */
@@ -28,3 +33,8 @@ export function mapIterable <T, R> (iter: IterableIterator<T>, map: (val: T) =>
 
   return iterator
 }
+
+export function peerIdFromString (str: string): PeerId {
+  const multihash = Digest.decode(base58btc.decode(`z${str}`))
+  return peerIdFromMultihash(multihash)
+}