chore: replace multibase with multiformats (#20)

Swaps the multibase library for multiformats as it's much smaller.

The supported encodings are the same so it should be a non-breaking change.

Author: achingbrain

.aegir.js

@@ -3,7 +3,7 @@
 /** @type {import('aegir').PartialOptions} */
 module.exports = {
   build: {
-    bundlesizeMax: '11KB',
+    bundlesizeMax: '7KB',
     config: {
       entryPoints: ['index.js']
     }

.github/workflows/main.yml

@@ -26,7 +26,7 @@ jobs:
     strategy:
       matrix:
         os: [windows-latest, ubuntu-latest, macos-latest]
-        node: [12, 14, 15]
+        node: [12, 14, 16]
       fail-fast: true
     steps:
       - uses: actions/checkout@v2
@@ -43,8 +43,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: microsoft/playwright-github-action@v1
       - run: npm install
-      - run: npx aegir test -t browser -t webworker --bail --cov
-      - uses: codecov/codecov-action@v1
+      - run: npx aegir test -t browser -t webworker --bail
   test-firefox:
     needs: check
     runs-on: ubuntu-latest

README.md

@@ -85,7 +85,7 @@ console.info(equals(a, a)) // true
 
 Returns a new `Uint8Array` created from the passed string and interpreted as the passed encoding.
 
-Supports `utf8` and any of the [multiformats encodings](https://www.npmjs.com/package/multibase#supported-encodings-see-srcconstantsjs).
+Supports `utf8` and any of the [multibase encodings](https://github.com/multiformats/multibase/blob/master/multibase.csv) as implemented by the [multiformats module](https://www.npmjs.com/package/multiformats).
 
 #### Example
 
@@ -102,7 +102,7 @@ console.info(fromString('01234', 'ascii')) // Uint8Array[48, 49 ...
 
 Returns a string created from the passed `Uint8Array` in the passed encoding.
 
-Supports `utf8` and any of the [multiformats encodings](https://www.npmjs.com/package/multibase#supported-encodings-see-srcconstantsjs).
+Supports `utf8` and any of the [multibase encodings](https://github.com/multiformats/multibase/blob/master/multibase.csv) as implemented by the [multiformats module](https://www.npmjs.com/package/multiformats).
 
 #### Example
 

from-string.js

@@ -1,32 +1,15 @@
 'use strict'
 
-const { encoding: getCodec } = require('multibase')
-const utf8Encoder = new TextEncoder()
+const bases = require('./util/bases')
 
 /**
- * @typedef {import('multibase/src/types').BaseName | 'utf8' | 'utf-8' | 'ascii' | undefined} SupportedEncodings
+ * @typedef {import('./util/bases').SupportedEncodings} SupportedEncodings
  */
 
-/**
- * Interprets each character in a string as a byte and
- * returns a Uint8Array of those bytes.
- *
- * @param {string} string - The string to turn into an array
- */
-function asciiStringToUint8Array (string) {
-  const array = new Uint8Array(string.length)
-
-  for (let i = 0; i < string.length; i++) {
-    array[i] = string.charCodeAt(i)
-  }
-
-  return array
-}
-
 /**
  * Create a `Uint8Array` from the passed string
  *
- * Supports `utf8`, `utf-8` and any encoding supported by the multibase module.
+ * Supports `utf8`, `utf-8`, `hex`, and any encoding supported by the multiformats module.
  *
  * Also `ascii` which is similar to node's 'binary' encoding.
  *
@@ -35,15 +18,14 @@ function asciiStringToUint8Array (string) {
  * @returns {Uint8Array}
  */
 function fromString (string, encoding = 'utf8') {
-  if (encoding === 'utf8' || encoding === 'utf-8') {
-    return utf8Encoder.encode(string)
-  }
+  const base = bases[encoding]
 
-  if (encoding === 'ascii') {
-    return asciiStringToUint8Array(string)
+  if (!base) {
+    throw new Error(`Unsupported encoding "${encoding}"`)
   }
 
-  return getCodec(encoding).decode(string)
+  // add multibase prefix
+  return base.decoder.decode(`${base.prefix}${string}`)
 }
 
 module.exports = fromString

package.json

@@ -27,7 +27,8 @@
     "xor.js",
     "dist/*.ts",
     "dist/*.map",
-    "dist/*.js"
+    "dist/*.js",
+    "util/*.js"
   ],
   "repository": {
     "type": "git",
@@ -36,18 +37,19 @@
   "scripts": {
     "prepare": "aegir build --no-bundle",
     "test": "aegir test",
-    "lint": "aegir lint",
+    "lint": "aegir ts -p check && aegir lint",
     "release": "aegir release",
     "release-minor": "aegir release --type minor",
     "release-major": "aegir release --type major",
     "build": "aegir build"
   },
   "license": "MIT",
   "dependencies": {
-    "multibase": "^4.0.1"
+    "multiformats": "^9.4.1"
   },
   "devDependencies": {
-    "aegir": "^33.1.0"
+    "aegir": "^34.0.2",
+    "util": "^0.12.4"
   },
   "eslintConfig": {
     "extends": "ipfs",

test/from-string.spec.js

@@ -3,6 +3,12 @@
 
 const { expect } = require('aegir/utils/chai')
 const fromString = require('../from-string')
+const toString = require('../to-string')
+const bases = require('../util/bases')
+
+/** @type {import('../util/bases').SupportedEncodings[]} */
+// @ts-ignore Object.keys returns a string[]
+const supportedBases = Object.keys(bases)
 
 describe('Uint8Array fromString', () => {
   it('creates a Uint8Array from a string', () => {
@@ -12,14 +18,16 @@ describe('Uint8Array fromString', () => {
     expect(fromString(str)).to.deep.equal(arr)
   })
 
-  it('creates a Uint8Array from a base16 string', () => {
-    const str = '00010203aabbcc'
-    const arr = Uint8Array.from([0, 1, 2, 3, 170, 187, 204])
+  supportedBases.forEach(base => {
+    it(`creates a Uint8Array from a ${base} string`, () => {
+      const arr = Uint8Array.from([0, 1, 2, 3])
+      const str = toString(arr, base)
 
-    expect(fromString(str, 'base16')).to.deep.equal(arr)
+      expect(fromString(str, base)).to.deep.equal(arr)
+    })
   })
 
-  it('creates a Uint8Array from a base64 string', () => {
+  it('creates a Uint8Array from a base64 string with non-printable utf8 characters', () => {
     const str = 'AAECA6q7zA'
     const arr = Uint8Array.from([0, 1, 2, 3, 170, 187, 204])
 

test/to-string.spec.js

@@ -12,14 +12,28 @@ describe('Uint8Array toString', () => {
     expect(toString(arr)).to.deep.equal(str)
   })
 
-  it('creates a hex string from a Uint8Array', () => {
+  it('creates a hex string from a Uint8Array with non-printable utf8 characters', () => {
     const str = '00010203aabbcc'
     const arr = Uint8Array.from([0, 1, 2, 3, 170, 187, 204])
 
     expect(toString(arr, 'base16')).to.deep.equal(str)
   })
 
-  it('creates a base64 string from a Uint8Array', () => {
+  it('creates a base32 string from a Uint8Array with non-printable utf8 characters', () => {
+    const str = 'aaaqea5kxpga'
+    const arr = Uint8Array.from([0, 1, 2, 3, 170, 187, 204])
+
+    expect(toString(arr, 'base32')).to.deep.equal(str)
+  })
+
+  it('creates a base36 string from a Uint8Array with non-printable utf8 characters', () => {
+    const str = '0e52zorf0'
+    const arr = Uint8Array.from([0, 1, 2, 3, 170, 187, 204])
+
+    expect(toString(arr, 'base36')).to.deep.equal(str)
+  })
+
+  it('creates a base64 string from a Uint8Array with non-printable utf8 characters', () => {
     const str = 'AAECA6q7zA'
     const arr = Uint8Array.from([0, 1, 2, 3, 170, 187, 204])
 

to-string.js

@@ -1,27 +1,11 @@
 'use strict'
 
-const { encoding: getCodec } = require('multibase')
-const utf8Decoder = new TextDecoder('utf8')
+const bases = require('./util/bases')
 
 /**
- * @typedef {import('multibase/src/types').BaseName | 'utf8' | 'utf-8' | 'ascii' | undefined} SupportedEncodings
+ * @typedef {import('./util/bases').SupportedEncodings} SupportedEncodings
  */
 
-/**
- * Turns a Uint8Array of bytes into a string with each
- * character being the char code of the corresponding byte
- *
- * @param {Uint8Array} array - The array to turn into a string
- */
-function uint8ArrayToAsciiString (array) {
-  let string = ''
-
-  for (let i = 0; i < array.length; i++) {
-    string += String.fromCharCode(array[i])
-  }
-  return string
-}
-
 /**
  * Turns a `Uint8Array` into a string.
  *
@@ -34,15 +18,14 @@ function uint8ArrayToAsciiString (array) {
  * @returns {string}
  */
 function toString (array, encoding = 'utf8') {
-  if (encoding === 'utf8' || encoding === 'utf-8') {
-    return utf8Decoder.decode(array)
-  }
+  const base = bases[encoding]
 
-  if (encoding === 'ascii') {
-    return uint8ArrayToAsciiString(array)
+  if (!base) {
+    throw new Error(`Unsupported encoding "${encoding}"`)
   }
 
-  return getCodec(encoding).encode(array)
+  // strip multibase prefix
+  return base.encoder.encode(array).substring(1)
 }
 
 module.exports = toString

tsconfig.json

@@ -1,10 +1,11 @@
 {
-    "extends": "./node_modules/aegir/src/config/tsconfig.aegir.json",
+    "extends": "aegir/src/config/tsconfig.aegir.json",
     "compilerOptions": {
         "outDir": "dist"
     },
     "include": [
       "test",
+      "util",
       "*.js",
       ".aegir.js"
     ]

util/bases.js

@@ -0,0 +1,75 @@
+  'use strict'
+
+const { bases } = require('multiformats/basics')
+
+/**
+ * @typedef {import('multiformats/bases/interface').MultibaseCodec<any>} MultibaseCodec
+ */
+
+/**
+ * @param {string} name
+ * @param {string} prefix
+ * @param {(buf: Uint8Array) => string} encode
+ * @param {(str: string) => Uint8Array} decode
+ * @returns {MultibaseCodec}
+ */
+function createCodec (name, prefix, encode, decode) {
+  return {
+    name,
+    prefix,
+    encoder: {
+      name,
+      prefix,
+      encode
+    },
+    decoder: {
+      decode
+    }
+  }
+}
+
+const string = createCodec('utf8', 'u', (buf) => {
+  const decoder = new TextDecoder('utf8')
+  return 'u' + decoder.decode(buf)
+}, (str) => {
+  const encoder = new TextEncoder()
+  return encoder.encode(str.substring(1))
+})
+
+const ascii = createCodec('ascii', 'a', (buf) => {
+  let string = 'a'
+
+  for (let i = 0; i < buf.length; i++) {
+    string += String.fromCharCode(buf[i])
+  }
+  return string
+}, (str) => {
+  str = str.substring(1)
+  const buf = new Uint8Array(str.length)
+
+  for (let i = 0; i < str.length; i++) {
+    buf[i] = str.charCodeAt(i)
+  }
+
+  return buf
+})
+
+/**
+ * @typedef {'utf8' | 'utf-8' | 'hex' | 'latin1' | 'ascii' | 'binary' | keyof bases } SupportedEncodings
+ */
+
+/**
+ * @type {Record<SupportedEncodings, MultibaseCodec>}
+ */
+const BASES = {
+  'utf8': string,
+  'utf-8': string,
+  'hex': bases.base16,
+  'latin1': ascii,
+  'ascii': ascii,
+  'binary': ascii,
+
+  ...bases
+}
+
+module.exports = BASES