feat: add types (#189)

BREAKING CHANGES:

entry point uses named exports

Author: hugomrdias

.aegir.js

@@ -0,0 +1,38 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Desktop (please complete the following information):**
+ - OS: [e.g. iOS]
+ - Browser [e.g. chrome, safari]
+ - Version [e.g. 22]
+
+**Smartphone (please complete the following information):**
+ - Device: [e.g. iPhone6]
+ - OS: [e.g. iOS8.1]
+ - Browser [e.g. stock browser, safari]
+ - Version [e.g. 22]
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,78 @@
+name: ci
+on:
+    push:
+        branches:
+            - master
+    pull_request:
+        branches:
+            - master
+
+jobs:
+    check:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v2
+            - run: npm install
+            - run: npx aegir lint
+            - run: npx aegir ts -p check
+            - run: npx aegir build
+            - run: npx aegir dep-check
+            - uses: ipfs/aegir/actions/bundle-size@master
+              with:
+                  github_token: ${{ secrets.GITHUB_TOKEN }}
+    test-node:
+        needs: check
+        runs-on: ${{ matrix.os }}
+        strategy:
+            matrix:
+                os: [windows-latest, ubuntu-latest, macos-latest]
+                node: [14, 15]
+            fail-fast: true
+        steps:
+            - uses: actions/checkout@v2
+            - uses: actions/setup-node@v1
+              with:
+                  node-version: ${{ matrix.node }}
+            - run: npm install
+            - run: npx aegir test -t node --bail --cov
+            - uses: codecov/codecov-action@v1
+    test-chrome:
+        needs: check
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v2
+            - uses: microsoft/playwright-github-action@v1
+            - run: npm install
+            - run: npx aegir test -t browser --bail --cov
+            - run: npx aegir test -t webworker --bail
+            - uses: codecov/codecov-action@v1
+    test-firefox:
+        needs: check
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v2
+            - uses: microsoft/playwright-github-action@v1
+            - run: npm install
+            - run: npx aegir test -t browser -t webworker --bail -- --browser firefox
+    test-webkit:
+        needs: check
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v2
+            - uses: microsoft/playwright-github-action@v1
+            - run: npm install
+            - run: npx aegir test -t browser -t webworker --bail -- --browser webkit
+    test-electron-main:
+        needs: check
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v2
+            - run: npm install
+            - run: npx xvfb-maybe aegir test -t electron-main --bail
+    test-electron-renderer:
+        needs: check
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v2
+            - run: npm install
+            - run: npx xvfb-maybe aegir test -t electron-renderer --bail

.github/workflows/main.yml

@@ -24,10 +24,8 @@ js-multiaddr
   - [Background](#background)
     - [What is multiaddr?](#what-is-multiaddr)
   - [Install](#install)
-    - [Setup](#setup)
-      - [Node.js](#nodejs)
-      - [Browser: Browserify, Webpack, other bundlers](#browser-browserify-webpack-other-bundlers)
-      - [Browser: `<script>` Tag](#browser-script-tag)
+    - [NPM](#npm)
+    - [Browser: `<script>` Tag](#browser-script-tag)
   - [Usage](#usage)
   - [API](#api)
   - [Resolvers](#resolvers)
@@ -48,30 +46,12 @@ A standard way to represent addresses that
 
 ## Install
 
+### NPM
 ```sh
 npm i multiaddr
 ```
 
-### Setup
-
-#### Node.js
-
-```js
-const multiaddr = require('multiaddr')
-```
-
-#### Browser: Browserify, Webpack, other bundlers
-
-The code published to npm that gets loaded on require is in fact a ES5
-transpiled version with the right shims added. This means that you can require
-it and use with your favourite bundler without having to adjust asset management
-process.
-
-```js
-const multiaddr = require('multiaddr')
-```
-
-#### Browser: `<script>` Tag
+### Browser: `<script>` Tag
 
 Loading this module through a script tag will make the `Multiaddr` obj available in
 the global namespace.
@@ -83,35 +63,43 @@ the global namespace.
 ## Usage
 
 ```js
-$ node
+// if we are coming from <= 8.x you can use the factory function 
+const { multiaddr } = require('multiaddr')
+const addr =  multiaddr("/ip4/127.0.0.1/udp/1234")
+// <Multiaddr /ip4/127.0.0.1/udp/1234>
 
-> const multiaddr = require('multiaddr')
+// or just the class directly
+const { Multiaddr } = require('multiaddr')
 
-> const addr = multiaddr("/ip4/127.0.0.1/udp/1234")
-<Multiaddr /ip4/127.0.0.1/udp/1234>
+const addr = new Multiaddr("/ip4/127.0.0.1/udp/1234")
+// <Multiaddr /ip4/127.0.0.1/udp/1234>
 
-> addr.bytes
-<Uint8Array 04 7f 00 00 01 11 04 d2>
+addr.bytes
+// <Uint8Array 04 7f 00 00 01 11 04 d2>
 
-> addr.toString()
-'/ip4/127.0.0.1/udp/1234'
+addr.toString()
+// '/ip4/127.0.0.1/udp/1234'
 
-> addr.protos()
+addr.protos()
+/* 
 [
   {code: 4, name: 'ip4', size: 32},
   {code: 273, name: 'udp', size: 16}
 ]
+*/
 
 // gives you an object that is friendly with what Node.js core modules expect for addresses
-> addr.nodeAddress()
+addr.nodeAddress()
+/*
 {
-  family: "4",
+  family: 4,
   port: 1234,
   address: "127.0.0.1"
 }
+*/
 
-> addr.encapsulate('/sctp/5678')
-<Multiaddr /ip4/127.0.0.1/udp/1234/sctp/5678>
+addr.encapsulate('/sctp/5678')
+// <Multiaddr /ip4/127.0.0.1/udp/1234/sctp/5678>
 ```
 
 ## API
@@ -124,10 +112,10 @@ https://multiformats.github.io/js-multiaddr/
 To provide multiaddr resolvers you can do:
 
 ```js
-const multiaddr = require('multiaddr')
+const { Multiaddr } = require('multiaddr')
 const resolvers = require('multiaddr/src/resolvers')
 
-multiaddr.resolvers.set('dnsaddr', resolvers.dnsaddrResolver)
+Multiaddr.resolvers.set('dnsaddr', resolvers.dnsaddrResolver)
 ```
 
 The available resolvers are:

.travis.yml

@@ -1,28 +1,29 @@
 'use strict'
 
-var multiaddr = require('../src')
-var log = console.log
+const { Multiaddr } = require('../src')
+// eslint-disable-next-line no-console
+const log = console.log
 
-var addr = multiaddr('/ip4/127.0.0.1/udp/1234')
+const addr = new Multiaddr('/ip4/127.0.0.1/udp/1234')
 log(addr)
 log(addr.bytes)
 log(addr.toString())
-log(multiaddr(addr.bytes))
+log(new Multiaddr(addr.bytes))
 
 log(addr.protoCodes())
 log(addr.protoNames())
 log(addr.protos())
 
 log(addr.nodeAddress())
-log(multiaddr.fromNodeAddress(addr.nodeAddress(), 'udp'))
+log(Multiaddr.fromNodeAddress(addr.nodeAddress(), 'udp'))
 
 log(addr.encapsulate('/sctp/5678'))
 log(addr.decapsulate('/udp'))
 
-var printer = multiaddr('/ip4/192.168.0.13/tcp/80')
-var proxy = multiaddr('/ip4/10.20.30.40/tcp/443')
-var printerOverProxy = proxy.encapsulate(printer)
+const printer = new Multiaddr('/ip4/192.168.0.13/tcp/80')
+const proxy = new Multiaddr('/ip4/10.20.30.40/tcp/443')
+const printerOverProxy = proxy.encapsulate(printer)
 log(printerOverProxy)
 
-var proxyAgain = printerOverProxy.decapsulate('/ip4')
+const proxyAgain = printerOverProxy.decapsulate('/ip4')
 log(proxyAgain)

README.md

@@ -10,7 +10,6 @@
     "test": "npm run test:node && npm run test:browser",
     "test:node": "aegir test --ts -t node",
     "test:browser": "aegir test -t browser",
-    "test:types": "npx tsc",
     "build": "aegir build",
     "release": "aegir release",
     "release-minor": "aegir release --type minor",
@@ -32,26 +31,30 @@
   "bugs": "https://github.com/multiformats/js-multiaddr/issues",
   "homepage": "https://github.com/multiformats/js-multiaddr",
   "browser": {
-    "dns": false
+    "./src/resolvers/dns.js": "./src/resolvers/dns.browser.js"
   },
   "dependencies": {
     "cids": "^1.0.0",
-    "class-is": "^1.1.0",
     "dns-over-http-resolver": "^1.0.0",
-    "err-code": "^2.0.3",
+    "err-code": "^3.0.1",
     "is-ip": "^3.1.0",
-    "multibase": "^3.0.0",
-    "uint8arrays": "^1.1.0",
-    "varint": "^5.0.0"
+    "multibase": "^4.0.2",
+    "uint8arrays": "^2.1.3",
+    "varint": "^6.0.0"
   },
   "devDependencies": {
-    "@types/chai": "^4.2.8",
-    "@types/dirty-chai": "^2.0.2",
-    "@types/mocha": "^8.0.1",
-    "@types/node": "^14.0.11",
-    "aegir": "^29.0.1",
-    "sinon": "^9.2.0",
-    "typescript": "^3.9.5"
+    "@types/varint": "^6.0.0",
+    "aegir": "^33.0.0",
+    "sinon": "^10.0.0",
+    "util": "^0.12.3"
+  },
+  "aegir": {
+    "build": {
+      "bundlesizeMax": "22kB"
+    }
+  },
+  "eslintConfig": {
+    "extends": "ipfs"
   },
   "contributors": [
     "David Dias <daviddias.p@gmail.com>",

documentation.yml

@@ -33,6 +33,9 @@ module.exports = {
 }
 
 // string -> [[str name, str addr]... ]
+/**
+ * @param {string} str
+ */
 function stringToStringTuples (str) {
   const tuples = []
   const parts = str.split('/').slice(1) // skip first empty elem
@@ -73,22 +76,31 @@ function stringToStringTuples (str) {
 }
 
 // [[str name, str addr]... ] -> string
+/**
+ * @param {[number, string?][]} tuples
+ */
 function stringTuplesToString (tuples) {
+  /** @type {Array<string | undefined>} */
   const parts = []
-  tuples.map(tup => {
+  tuples.map((tup) => {
     const proto = protoFromTuple(tup)
     parts.push(proto.name)
     if (tup.length > 1) {
       parts.push(tup[1])
     }
+    return null
   })
 
   return cleanPath(parts.join('/'))
 }
 
 // [[str name, str addr]... ] -> [[int code, Uint8Array]... ]
+/**
+ * @param {Array<string[] | string >} tuples
+ * @returns {[number , Uint8Array?][]}
+ */
 function stringTuplesToTuples (tuples) {
-  return tuples.map(tup => {
+  return tuples.map((tup) => {
     if (!Array.isArray(tup)) {
       tup = [tup]
     }
@@ -100,20 +112,31 @@ function stringTuplesToTuples (tuples) {
   })
 }
 
-// [[int code, Uint8Array]... ] -> [[str name, str addr]... ]
+/**
+ * Convert tuples to string tuples
+ *
+ * [[int code, Uint8Array]... ] -> [[int code, str addr]... ]
+ *
+ * @param {Array<[number, Uint8Array?]>} tuples
+ * @returns {Array<[number, string?]>}
+ */
+
 function tuplesToStringTuples (tuples) {
   return tuples.map(tup => {
     const proto = protoFromTuple(tup)
-    if (tup.length > 1) {
+    if (tup[1]) {
       return [proto.code, convert.toString(proto.code, tup[1])]
     }
     return [proto.code]
   })
 }
 
 // [[int code, Uint8Array ]... ] -> Uint8Array
+/**
+ * @param {[number, Uint8Array?][]} tuples
+ */
 function tuplesToBytes (tuples) {
-  return fromBytes(uint8ArrayConcat(tuples.map(tup => {
+  return fromBytes(uint8ArrayConcat(tuples.map((/** @type {any[]} */ tup) => {
     const proto = protoFromTuple(tup)
     let buf = Uint8Array.from(varint.encode(proto.code))
 
@@ -125,6 +148,10 @@ function tuplesToBytes (tuples) {
   })))
 }
 
+/**
+ * @param {import("./types").Protocol} p
+ * @param {Uint8Array | number[]} addr
+ */
 function sizeForAddr (p, addr) {
   if (p.size > 0) {
     return p.size / 8
@@ -136,8 +163,13 @@ function sizeForAddr (p, addr) {
   }
 }
 
-// Uint8Array -> [[int code, Uint8Array ]... ]
+/**
+ *
+ * @param {Uint8Array} buf
+ * @returns {Array<[number, Uint8Array?]>}
+ */
 function bytesToTuples (buf) {
+  /** @type {Array<[number, Uint8Array?]>} */
   const tuples = []
   let i = 0
   while (i < buf.length) {
@@ -170,13 +202,19 @@ function bytesToTuples (buf) {
 }
 
 // Uint8Array -> String
+/**
+ * @param {Uint8Array} buf
+ */
 function bytesToString (buf) {
   const a = bytesToTuples(buf)
   const b = tuplesToStringTuples(a)
   return stringTuplesToString(b)
 }
 
 // String -> Uint8Array
+/**
+ * @param {string} str
+ */
 function stringToBytes (str) {
   str = cleanPath(str)
   const a = stringToStringTuples(str)
@@ -186,17 +224,26 @@ function stringToBytes (str) {
 }
 
 // String -> Uint8Array
+/**
+ * @param {string} str
+ */
 function fromString (str) {
   return stringToBytes(str)
 }
 
 // Uint8Array -> Uint8Array
+/**
+ * @param {Uint8Array} buf
+ */
 function fromBytes (buf) {
   const err = validateBytes(buf)
   if (err) throw err
   return Uint8Array.from(buf) // copy
 }
 
+/**
+ * @param {Uint8Array} buf
+ */
 function validateBytes (buf) {
   try {
     bytesToTuples(buf) // try to parse. will throw if breaks
@@ -205,18 +252,30 @@ function validateBytes (buf) {
   }
 }
 
+/**
+ * @param {Uint8Array} buf
+ */
 function isValidBytes (buf) {
   return validateBytes(buf) === undefined
 }
 
+/**
+ * @param {string} str
+ */
 function cleanPath (str) {
-  return '/' + str.trim().split('/').filter(a => a).join('/')
+  return '/' + str.trim().split('/').filter((/** @type {any} */ a) => a).join('/')
 }
 
+/**
+ * @param {string} str
+ */
 function ParseError (str) {
   return new Error('Error parsing address: ' + str)
 }
 
+/**
+ * @param {any[]} tup
+ */
 function protoFromTuple (tup) {
   const proto = protocols(tup[0])
   return proto

examples/try.js

@@ -12,6 +12,10 @@ const uint8ArrayConcat = require('uint8arrays/concat')
 module.exports = Convert
 
 // converts (serializes) addresses
+/**
+ * @param {string} proto
+ * @param {string | Uint8Array} a
+ */
 function Convert (proto, a) {
   if (a instanceof Uint8Array) {
     return Convert.toString(proto, a)
@@ -20,9 +24,16 @@ function Convert (proto, a) {
   }
 }
 
+/**
+ * Convert [code,Uint8Array] to string
+ *
+ * @param {number|string} proto
+ * @param {Uint8Array} buf
+ * @returns {string}
+ */
 Convert.toString = function convertToString (proto, buf) {
-  proto = protocols(proto)
-  switch (proto.code) {
+  const protocol = protocols(proto)
+  switch (protocol.code) {
     case 4: // ipv4
     case 41: // ipv6
       return bytes2ip(buf)
@@ -31,7 +42,7 @@ Convert.toString = function convertToString (proto, buf) {
     case 273: // udp
     case 33: // dccp
     case 132: // sctp
-      return bytes2port(buf)
+      return bytes2port(buf).toString()
 
     case 53: // dns
     case 54: // dns4
@@ -52,9 +63,9 @@ Convert.toString = function convertToString (proto, buf) {
   }
 }
 
-Convert.toBytes = function convertToBytes (proto, str) {
-  proto = protocols(proto)
-  switch (proto.code) {
+Convert.toBytes = function convertToBytes (/** @type {string | number } */ proto, /** @type {string} */ str) {
+  const protocol = protocols(proto)
+  switch (protocol.code) {
     case 4: // ipv4
       return ip2bytes(str)
     case 41: // ipv6
@@ -85,13 +96,19 @@ Convert.toBytes = function convertToBytes (proto, str) {
   }
 }
 
+/**
+ * @param {string} ipString
+ */
 function ip2bytes (ipString) {
   if (!ip.isIP(ipString)) {
     throw new Error('invalid ip address')
   }
   return ip.toBytes(ipString)
 }
 
+/**
+ * @param {Uint8Array} ipBuff
+ */
 function bytes2ip (ipBuff) {
   const ipString = ip.toString(ipBuff)
   if (!ipString || !ip.isIP(ipString)) {
@@ -100,6 +117,9 @@ function bytes2ip (ipBuff) {
   return ipString
 }
 
+/**
+ * @param {number} port
+ */
 function port2bytes (port) {
   const buf = new ArrayBuffer(2)
   const view = new DataView(buf)
@@ -108,17 +128,26 @@ function port2bytes (port) {
   return new Uint8Array(buf)
 }
 
+/**
+ * @param {Uint8Array} buf
+ */
 function bytes2port (buf) {
   const view = new DataView(buf.buffer)
   return view.getUint16(0)
 }
 
+/**
+ * @param {string} str
+ */
 function str2bytes (str) {
   const buf = uint8ArrayFromString(str)
   const size = Uint8Array.from(varint.encode(buf.length))
   return uint8ArrayConcat([size, buf], size.length + buf.length)
 }
 
+/**
+ * @param {Uint8Array} buf
+ */
 function bytes2str (buf) {
   const size = varint.decode(buf)
   buf = buf.slice(varint.decode.bytes)
@@ -130,13 +159,22 @@ function bytes2str (buf) {
   return uint8ArrayToString(buf)
 }
 
+/**
+ * @param {string | Uint8Array | CID} hash
+ */
 function mh2bytes (hash) {
   // the address is a varint prefixed multihash string representation
   const mh = new CID(hash).multihash
   const size = Uint8Array.from(varint.encode(mh.length))
   return uint8ArrayConcat([size, mh], size.length + mh.length)
 }
 
+/**
+ * Converts bytes to bas58btc string
+ *
+ * @param {Uint8Array} buf
+ * @returns {string} bas58btc string
+ */
 function bytes2mh (buf) {
   const size = varint.decode(buf)
   const address = buf.slice(varint.decode.bytes)
@@ -148,6 +186,9 @@ function bytes2mh (buf) {
   return uint8ArrayToString(address, 'base58btc')
 }
 
+/**
+ * @param {string} str
+ */
 function onion2bytes (str) {
   const addr = str.split(':')
   if (addr.length !== 2) {
@@ -169,6 +210,9 @@ function onion2bytes (str) {
   return uint8ArrayConcat([buf, portBuf], buf.length + portBuf.length)
 }
 
+/**
+ * @param {string} str
+ */
 function onion32bytes (str) {
   const addr = str.split(':')
   if (addr.length !== 2) {
@@ -189,6 +233,9 @@ function onion32bytes (str) {
   return uint8ArrayConcat([buf, portBuf], buf.length + portBuf.length)
 }
 
+/**
+ * @param {Uint8Array} buf
+ */
 function bytes2onion (buf) {
   const addrBytes = buf.slice(0, buf.length - 2)
   const portBytes = buf.slice(buf.length - 2)

intro.md

@@ -8,22 +8,25 @@ const isV4 = isIp.v4
 const isV6 = isIp.v6
 
 // Copied from https://github.com/indutny/node-ip/blob/master/lib/ip.js#L7
+// @ts-ignore - this is copied from the link above better to keep it the same
 const toBytes = function (ip, buff, offset) {
   offset = ~~offset
 
-  var result
+  let result
 
   if (isV4(ip)) {
     result = buff || new Uint8Array(offset + 4)
+    // @ts-ignore
+    // eslint-disable-next-line array-callback-return
     ip.split(/\./g).map(function (byte) {
       result[offset++] = parseInt(byte, 10) & 0xff
     })
   } else if (isV6(ip)) {
-    var sections = ip.split(':', 8)
+    const sections = ip.split(':', 8)
 
-    var i
+    let i
     for (i = 0; i < sections.length; i++) {
-      var isv4 = isV4(sections[i])
+      const isv4 = isV4(sections[i])
       var v4Buffer
 
       if (isv4) {
@@ -42,7 +45,7 @@ const toBytes = function (ip, buff, offset) {
       while (sections.length < 8) sections.push('0')
     } else if (sections.length < 8) {
       for (i = 0; i < sections.length && sections[i] !== ''; i++);
-      var argv = [i, '1']
+      const argv = [i, '1']
       for (i = 9 - sections.length; i > 0; i--) {
         argv.push('0')
       }
@@ -51,7 +54,7 @@ const toBytes = function (ip, buff, offset) {
 
     result = buff || new Uint8Array(offset + 16)
     for (i = 0; i < sections.length; i++) {
-      var word = parseInt(sections[i], 16)
+      const word = parseInt(sections[i], 16)
       result[offset++] = (word >> 8) & 0xff
       result[offset++] = word & 0xff
     }
@@ -65,12 +68,13 @@ const toBytes = function (ip, buff, offset) {
 }
 
 // Copied from https://github.com/indutny/node-ip/blob/master/lib/ip.js#L63
+// @ts-ignore - this is copied from the link above better to keep it the same
 const toString = function (buff, offset, length) {
   offset = ~~offset
   length = length || (buff.length - offset)
 
-  var result = []
-  var string
+  const result = []
+  let string
   const view = new DataView(buff.buffer)
   if (length === 4) {
     // IPv4

package.json

@@ -1,13 +1,20 @@
 'use strict'
+/** @typedef {import("./types").Protocol} Protocol */
 
+/**
+ * Protocols
+ *
+ * @param {number | string} proto
+ * @returns {Protocol}
+ */
 function Protocols (proto) {
   if (typeof (proto) === 'number') {
     if (Protocols.codes[proto]) {
       return Protocols.codes[proto]
     }
 
     throw new Error('no protocol with code: ' + proto)
-  } else if (typeof (proto) === 'string' || proto instanceof String) {
+  } else if (typeof (proto) === 'string') {
     if (Protocols.names[proto]) {
       return Protocols.names[proto]
     }
@@ -22,6 +29,7 @@ const V = -1
 Protocols.lengthPrefixedVarSize = V
 Protocols.V = V
 
+/** @type {Array<[number, number, string, (string|boolean)?, string?]>} */
 Protocols.table = [
   [4, 32, 'ip4'],
   [6, 16, 'tcp'],
@@ -58,19 +66,32 @@ Protocols.table = [
   [480, 0, 'http'],
   [777, V, 'memory']
 ]
-
+/** @type {Record<string,Protocol>} */
 Protocols.names = {}
+/** @type {Record<number,Protocol>} */
 Protocols.codes = {}
 
 // populate tables
 Protocols.table.map(row => {
   const proto = p.apply(null, row)
   Protocols.codes[proto.code] = proto
   Protocols.names[proto.name] = proto
+  return null
 })
 
 Protocols.object = p
 
+/**
+ *
+ * Create a protocol
+ *
+ * @param {number} code
+ * @param {number} size
+ * @param {string} name
+ * @param {any} [resolvable]
+ * @param {any} [path]
+ * @returns {Protocol}
+ */
 function p (code, size, name, resolvable, path) {
   return {
     code,

src/codec.js

@@ -0,0 +1,7 @@
+'use strict'
+
+/** @type {import('dns').promises.Resolver} */
+// @ts-ignore - has no types
+const dns = require('dns-over-http-resolver')
+
+module.exports = dns

src/convert.js

@@ -1,14 +1,3 @@
 'use strict'
 
-let dns
-
-try {
-  dns = require('dns').promises
-  if (!dns) {
-    throw new Error('no dns available')
-  }
-} catch (err) {
-  dns = require('dns-over-http-resolver')
-}
-
-module.exports = dns
+module.exports = require('dns').promises.Resolver

src/index.d.ts

@@ -1,25 +1,27 @@
 'use strict'
 
-const Multiaddr = require('..') // eslint-disable-line  no-unused-vars
 const protocols = require('../protocols-table')
 
 const { code: dnsaddrCode } = protocols('dnsaddr')
 
+/**
+ * @typedef {import('..').Multiaddr} Multiaddr
+ */
+
 /**
  * Resolver for dnsaddr addresses.
  *
  * @param {Multiaddr} addr
- * @returns {Promise<Array<string>>}
+ * @returns {Promise<string[]>}
  */
 async function dnsaddrResolver (addr) {
-  const { Resolver } = require('./dns')
+  const Resolver = require('./dns')
   const resolver = new Resolver()
 
   const peerId = addr.getPeerId()
   const [, hostname] = addr.stringTuples().find(([proto]) => proto === dnsaddrCode) || []
 
   const records = await resolver.resolveTxt(`_dnsaddr.${hostname}`)
-  // @ts-ignore
   let addresses = records.flat().map((a) => a.split('=')[1])
 
   if (peerId) {

src/index.js

@@ -0,0 +1,14 @@
+export interface Protocol {
+  code: number
+  size: number
+  name: string
+  resolvable?: boolean | undefined
+  path?: boolean | undefined
+}
+
+export interface MultiaddrObject {
+  family: 4 | 6
+  host: string
+  transport: string
+  port: number
+}

src/ip.js

@@ -24,6 +24,7 @@ describe('protocols', () => {
 
     it('else', () => {
       expect(
+        // @ts-expect-error
         () => protocols({ hi: 34 })
       ).to.throw(
         /invalid protocol id type/

src/protocols-table.js

@@ -4,9 +4,9 @@
 const { expect } = require('aegir/utils/chai')
 const sinon = require('sinon')
 
-const multiaddr = require('../src')
+const { Multiaddr } = require('../src')
 const resolvers = require('../src/resolvers')
-const { Resolver } = require('../src/resolvers/dns')
+const Resolver = require('../src/resolvers/dns')
 
 const dnsaddrStub1 = [
   ['dnsaddr=/dnsaddr/ams-1.bootstrap.libp2p.io/p2p/QmSoLer265NRgSp2LA3dPaeykiS1J6DifTC88f5uVQKNAd'],
@@ -28,7 +28,7 @@ const dnsaddrStub2 = [
 
 describe('multiaddr resolve', () => {
   it('should throw if no resolver is available', async () => {
-    const ma = multiaddr('/dnsaddr/bootstrap.libp2p.io')
+    const ma = new Multiaddr('/dnsaddr/bootstrap.libp2p.io')
 
     // Resolve
     await expect(ma.resolve()).to.eventually.be.rejected()
@@ -38,15 +38,15 @@ describe('multiaddr resolve', () => {
   describe('dnsaddr', () => {
     before(() => {
       // Set resolvers
-      multiaddr.resolvers.set('dnsaddr', resolvers.dnsaddrResolver)
+      Multiaddr.resolvers.set('dnsaddr', resolvers.dnsaddrResolver)
     })
 
     afterEach(() => {
       sinon.restore()
     })
 
     it('can resolve dnsaddr without no peerId', async () => {
-      const ma = multiaddr('/dnsaddr/bootstrap.libp2p.io')
+      const ma = new Multiaddr('/dnsaddr/bootstrap.libp2p.io')
 
       const stub = sinon.stub(Resolver.prototype, 'resolveTxt')
       stub.onCall(0).returns(Promise.resolve(dnsaddrStub1))
@@ -58,12 +58,12 @@ describe('multiaddr resolve', () => {
       resolvedMas.forEach((ma, index) => {
         const stubAddr = dnsaddrStub1[index][0].split('=')[1]
 
-        expect(ma.equals(multiaddr(stubAddr))).to.equal(true)
+        expect(ma.equals(new Multiaddr(stubAddr))).to.equal(true)
       })
     })
 
     it('can resolve dnsaddr with peerId', async () => {
-      const ma = multiaddr('/dnsaddr/bootstrap.libp2p.io/p2p/QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb')
+      const ma = new Multiaddr('/dnsaddr/bootstrap.libp2p.io/p2p/QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb')
 
       const stub = sinon.stub(Resolver.prototype, 'resolveTxt')
       stub.onCall(0).returns(Promise.resolve(dnsaddrStub1))
@@ -73,11 +73,11 @@ describe('multiaddr resolve', () => {
       const resolvedMas = await ma.resolve()
 
       expect(resolvedMas).to.have.length(1)
-      expect(resolvedMas[0].equals(multiaddr('/dnsaddr/ams-2.bootstrap.libp2p.io/p2p/QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb'))).to.eql(true)
+      expect(resolvedMas[0].equals(new Multiaddr('/dnsaddr/ams-2.bootstrap.libp2p.io/p2p/QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb'))).to.eql(true)
     })
 
     it('can resolve dnsaddr with peerId two levels', async () => {
-      const ma = multiaddr('/dnsaddr/bootstrap.libp2p.io/p2p/QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb')
+      const ma = new Multiaddr('/dnsaddr/bootstrap.libp2p.io/p2p/QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb')
 
       const stub = sinon.stub(Resolver.prototype, 'resolveTxt')
       stub.onCall(0).returns(Promise.resolve(dnsaddrStub1))
@@ -93,10 +93,11 @@ describe('multiaddr resolve', () => {
       const resolvedMas = resolvedSecondMas.flat()
 
       expect(resolvedMas).to.have.length(dnsaddrStub2.length)
-      resolvedMas.forEach((ma, index) => {
+
+      resolvedMas.forEach((/** @type {Multiaddr} */ma, /** @type {number} */ index) => {
         const stubAddr = dnsaddrStub2[index][0].split('=')[1]
 
-        expect(ma.equals(multiaddr(stubAddr))).to.equal(true)
+        expect(ma.equals(new Multiaddr(stubAddr))).to.equal(true)
       })
     })
   })

src/resolvers/dns.browser.js

@@ -1,18 +1,10 @@
 {
+  "extends": "aegir/src/config/tsconfig.aegir.json",
   "compilerOptions": {
-    "module": "commonjs",
-    "lib": ["es6"],
-    "target": "ES5",
-    "noImplicitAny": false,
-    "noImplicitThis": true,
-    "strictFunctionTypes": true,
-    "strictNullChecks": true,
-    "esModuleInterop": true,
-    "resolveJsonModule": true,
-    "allowJs": true,
-    "checkJs": true,
-    "noEmit": true,
-    "forceConsistentCasingInFileNames": true
+      "outDir": "dist"
   },
-  "include": ["src/index.d.ts", "test/**/*.spec.js", "test/**/*.spec.ts"]
-}
+  "include": [
+    "test",
+    "src"
+  ]
+}