@libp2p/autonat 3.0.13 → 3.0.14-709b3fa2e

package/src/pb/index.ts

@@ -1,4 +1,4 @@
-import { decodeMessage, encodeMessage, enumeration, MaxLengthError, message } from 'protons-runtime'
+import { decodeMessage, encodeMessage, enumeration, MaxLengthError, message, streamMessage } from 'protons-runtime'
 import type { Codec, DecodeOptions } from 'protons-runtime'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
@@ -67,7 +67,7 @@ export namespace Message {
             w.bytes(obj.id)
           }
 
-          if (obj.addrs != null) {
+          if (obj.addrs != null && obj.addrs.length > 0) {
             for (const value of obj.addrs) {
               w.uint32(18)
               w.bytes(value)
@@ -94,7 +94,7 @@ export namespace Message {
               }
               case 2: {
                 if (opts.limits?.addrs != null && obj.addrs.length === opts.limits.addrs) {
-                  throw new MaxLengthError('Decode error - map field "addrs" had too many elements')
+                  throw new MaxLengthError('Decode error - repeated field "addrs" had too many elements')
                 }
 
                 obj.addrs.push(reader.bytes())
@@ -108,19 +108,73 @@ export namespace Message {
           }
 
           return obj
+        }, function * (reader, length, prefix, opts = {}) {
+          const obj = {
+            addrs: 0
+          }
+
+          const end = length == null ? reader.len : reader.pos + length
+
+          while (reader.pos < end) {
+            const tag = reader.uint32()
+
+            switch (tag >>> 3) {
+              case 1: {
+                yield {
+                  field: `${prefix}.id`,
+                  value: reader.bytes()
+                }
+                break
+              }
+              case 2: {
+                if (opts.limits?.addrs != null && obj.addrs === opts.limits.addrs) {
+                  throw new MaxLengthError('Streaming decode error - repeated field "addrs" had too many elements')
+                }
+
+                yield {
+                  field: `${prefix}.addrs[]`,
+                  index: obj.addrs,
+                  value: reader.bytes()
+                }
+
+                obj.addrs++
+
+                break
+              }
+              default: {
+                reader.skipType(tag & 7)
+                break
+              }
+            }
+          }
         })
       }
 
       return _codec
     }
 
-    export const encode = (obj: Partial<PeerInfo>): Uint8Array => {
+    export interface PeerInfoIdFieldEvent {
+      field: '$.id'
+      value: Uint8Array
+    }
+
+    export interface PeerInfoAddrsFieldEvent {
+      field: '$.addrs[]'
+      index: number
+      value: Uint8Array
+    }
+
+    export function encode (obj: Partial<PeerInfo>): Uint8Array {
       return encodeMessage(obj, PeerInfo.codec())
     }
 
-    export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<PeerInfo>): PeerInfo => {
+    export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<PeerInfo>): PeerInfo {
       return decodeMessage(buf, PeerInfo.codec(), opts)
     }
+
+    export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<PeerInfo>): Generator<PeerInfoIdFieldEvent | PeerInfoAddrsFieldEvent> {
+      return streamMessage(buf, PeerInfo.codec(), opts)
+    }
   }
 
   export interface Dial {
@@ -168,19 +222,54 @@ export namespace Message {
           }
 
           return obj
+        }, function * (reader, length, prefix, opts = {}) {
+          const end = length == null ? reader.len : reader.pos + length
+
+          while (reader.pos < end) {
+            const tag = reader.uint32()
+
+            switch (tag >>> 3) {
+              case 1: {
+                yield * Message.PeerInfo.codec().stream(reader, reader.uint32(), `${prefix}.peer`, {
+                  limits: opts.limits?.peer
+                })
+
+                break
+              }
+              default: {
+                reader.skipType(tag & 7)
+                break
+              }
+            }
+          }
         })
       }
 
       return _codec
     }
 
-    export const encode = (obj: Partial<Dial>): Uint8Array => {
+    export interface DialPeerIdFieldEvent {
+      field: '$.peer.id'
+      value: Uint8Array
+    }
+
+    export interface DialPeerAddrsFieldEvent {
+      field: '$.peer.addrs[]'
+      index: number
+      value: Uint8Array
+    }
+
+    export function encode (obj: Partial<Dial>): Uint8Array {
       return encodeMessage(obj, Dial.codec())
     }
 
-    export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Dial>): Dial => {
+    export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Dial>): Dial {
       return decodeMessage(buf, Dial.codec(), opts)
     }
+
+    export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Dial>): Generator<DialPeerIdFieldEvent | DialPeerAddrsFieldEvent> {
+      return streamMessage(buf, Dial.codec(), opts)
+    }
   }
 
   export interface DialResponse {
@@ -246,19 +335,72 @@ export namespace Message {
           }
 
           return obj
+        }, function * (reader, length, prefix, opts = {}) {
+          const end = length == null ? reader.len : reader.pos + length
+
+          while (reader.pos < end) {
+            const tag = reader.uint32()
+
+            switch (tag >>> 3) {
+              case 1: {
+                yield {
+                  field: `${prefix}.status`,
+                  value: Message.ResponseStatus.codec().decode(reader)
+                }
+                break
+              }
+              case 2: {
+                yield {
+                  field: `${prefix}.statusText`,
+                  value: reader.string()
+                }
+                break
+              }
+              case 3: {
+                yield {
+                  field: `${prefix}.addr`,
+                  value: reader.bytes()
+                }
+                break
+              }
+              default: {
+                reader.skipType(tag & 7)
+                break
+              }
+            }
+          }
         })
       }
 
       return _codec
     }
 
-    export const encode = (obj: Partial<DialResponse>): Uint8Array => {
+    export interface DialResponseStatusFieldEvent {
+      field: '$.status'
+      value: Message.ResponseStatus
+    }
+
+    export interface DialResponseStatusTextFieldEvent {
+      field: '$.statusText'
+      value: string
+    }
+
+    export interface DialResponseAddrFieldEvent {
+      field: '$.addr'
+      value: Uint8Array
+    }
+
+    export function encode (obj: Partial<DialResponse>): Uint8Array {
       return encodeMessage(obj, DialResponse.codec())
     }
 
-    export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<DialResponse>): DialResponse => {
+    export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<DialResponse>): DialResponse {
       return decodeMessage(buf, DialResponse.codec(), opts)
     }
+
+    export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<DialResponse>): Generator<DialResponseStatusFieldEvent | DialResponseStatusTextFieldEvent | DialResponseAddrFieldEvent> {
+      return streamMessage(buf, DialResponse.codec(), opts)
+    }
   }
 
   let _codec: Codec<Message>
@@ -321,17 +463,86 @@ export namespace Message {
         }
 
         return obj
+      }, function * (reader, length, prefix, opts = {}) {
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1: {
+              yield {
+                field: `${prefix}.type`,
+                value: Message.MessageType.codec().decode(reader)
+              }
+              break
+            }
+            case 2: {
+              yield * Message.Dial.codec().stream(reader, reader.uint32(), `${prefix}.dial`, {
+                limits: opts.limits?.dial
+              })
+
+              break
+            }
+            case 3: {
+              yield * Message.DialResponse.codec().stream(reader, reader.uint32(), `${prefix}.dialResponse`, {
+                limits: opts.limits?.dialResponse
+              })
+
+              break
+            }
+            default: {
+              reader.skipType(tag & 7)
+              break
+            }
+          }
+        }
       })
     }
 
     return _codec
   }
 
-  export const encode = (obj: Partial<Message>): Uint8Array => {
+  export interface MessageTypeFieldEvent {
+    field: '$.type'
+    value: Message.MessageType
+  }
+
+  export interface MessageDialPeerIdFieldEvent {
+    field: '$.dial.peer.id'
+    value: Uint8Array
+  }
+
+  export interface MessageDialPeerAddrsFieldEvent {
+    field: '$.dial.peer.addrs[]'
+    index: number
+    value: Uint8Array
+  }
+
+  export interface MessageDialResponseStatusFieldEvent {
+    field: '$.dialResponse.status'
+    value: Message.ResponseStatus
+  }
+
+  export interface MessageDialResponseStatusTextFieldEvent {
+    field: '$.dialResponse.statusText'
+    value: string
+  }
+
+  export interface MessageDialResponseAddrFieldEvent {
+    field: '$.dialResponse.addr'
+    value: Uint8Array
+  }
+
+  export function encode (obj: Partial<Message>): Uint8Array {
     return encodeMessage(obj, Message.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Message>): Message => {
+  export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Message>): Message {
     return decodeMessage(buf, Message.codec(), opts)
   }
+
+  export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Message>): Generator<MessageTypeFieldEvent | MessageDialPeerIdFieldEvent | MessageDialPeerAddrsFieldEvent | MessageDialResponseStatusFieldEvent | MessageDialResponseStatusTextFieldEvent | MessageDialResponseAddrFieldEvent> {
+    return streamMessage(buf, Message.codec(), opts)
+  }
 }

package/dist/typedoc-urls.json

@@ -1,8 +0,0 @@
-{
-  "AutoNATComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_autonat.AutoNATComponents.html",
-  ".:AutoNATComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_autonat.AutoNATComponents.html",
-  "AutoNATServiceInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_autonat.AutoNATServiceInit.html",
-  ".:AutoNATServiceInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_autonat.AutoNATServiceInit.html",
-  "autoNAT": "https://libp2p.github.io/js-libp2p/functions/_libp2p_autonat.autoNAT.html",
-  ".:autoNAT": "https://libp2p.github.io/js-libp2p/functions/_libp2p_autonat.autoNAT.html"
-}