feat: bundle base58btc and base32 encoders

Author: Gozala

README.md

@@ -23,10 +23,7 @@ const bytes = dagcbor.encode({ hello: 'world' })
 
 const hash = await sha256.digest(bytes)
 // raw codec is the only codec that is there by default
-const cid = CID.create(1, dagcbor.code, hash, {
-  base: base32,
-  base58btc
-})
+const cid = CID.create(1, dagcbor.code, hash)
 ```
 
 However, if you're doing this much you should probably use multiformats
@@ -35,9 +32,10 @@ with the `Block` API.
 ```js
 // Import basics package with dep-free codecs, hashes, and base encodings
 import { block } from 'multiformats/basics'
+import { sha256 } from 'multiformats/hashes/sha2'
 import dagcbor from '@ipld/dag-cbor'
 
-const encoder = block.encoder(dagcbor)
+const encoder = block.encoder(dagcbor, { hasher: sha256 })
 const hello = encoder.encode({ hello: 'world' })
 const cid = await hello.cid()
 ```

package.json

@@ -48,10 +48,19 @@
       "import": "./src/bases/base64-import.js",
       "browser": "./src/bases/base64-browser.js"
     },
+    "./hashes/hasher": {
+      "import": "./src/hashes/hasher.js"
+    },
+    "./hashes/digest": {
+      "import": "./src/hashes/digest.js"
+    },
     "./hashes/sha2": {
       "browser": "./src/hashes/sha2-browser.js",
       "import": "./src/hashes/sha2.js"
     },
+    "./codecs/codec": {
+      "import": "./src/codecs/codec.js"
+    },
     "./codecs/json": {
       "import": "./src/codecs/json.js"
     },

src/bases/base.js

@@ -7,11 +7,11 @@
  */
 
 /**
- * @template T
+ * @template {string} T
  * @typedef {import('./interface').Multibase<T>} Multibase
  */
 /**
- * @template T
+ * @template {string} T
  * @typedef {import('./interface').MultibaseEncoder<T>} MultibaseEncoder
  */
 
@@ -42,16 +42,24 @@ class Encoder {
    * @returns {Multibase<Prefix>}
    */
   encode (bytes) {
-    // @ts-ignore
-    return `${this.prefix}${this.baseEncode(bytes)}`
+    if (bytes instanceof Uint8Array) {
+      return `${this.prefix}${this.baseEncode(bytes)}`
+    } else {
+      throw Error('Unknown type, must be binary type')
+    }
   }
 }
 
 /**
- * @template T
+ * @template {string} T
  * @typedef {import('./interface').MultibaseDecoder<T>} MultibaseDecoder
  */
 
+/**
+ * @template {string} T
+ * @typedef {import('./interface').UnibaseDecoder<T>} UnibaseDecoder
+ */
+
 /**
  * Class represents both BaseDecoder and MultibaseDecoder so it could be used
  * to decode multibases (with matching prefix) or just base decode strings
@@ -60,6 +68,7 @@ class Encoder {
  * @template {string} Base
  * @template {string} Prefix
  * @implements {MultibaseDecoder<Prefix>}
+ * @implements {UnibaseDecoder<Prefix>}
  * @implements {BaseDecoder}
  */
 class Decoder {
@@ -78,13 +87,83 @@ class Decoder {
    * @param {string} text
    */
   decode (text) {
-    switch (text[0]) {
-      case this.prefix: {
-        return this.baseDecode(text.slice(1))
-      }
-      default: {
-        throw Error(`${this.name} expects input starting with ${this.prefix} and can not decode "${text}"`)
+    if (typeof text === 'string') {
+      switch (text[0]) {
+        case this.prefix: {
+          return this.baseDecode(text.slice(1))
+        }
+        default: {
+          throw Error(`${this.name} expects input starting with ${this.prefix} and can not decode "${text}"`)
+        }
       }
+    } else {
+      throw Error('Can only multibase decode strings')
+    }
+  }
+
+  /**
+   * @template {string} OtherPrefix
+   * @param {UnibaseDecoder<OtherPrefix>|ComposedDecoder<OtherPrefix>} decoder
+   * @returns {ComposedDecoder<Prefix|OtherPrefix>}
+   */
+  or (decoder) {
+    if (decoder instanceof ComposedDecoder) {
+      return new ComposedDecoder({ [this.prefix]: this, ...decoder.decoders })
+    } else {
+      return new ComposedDecoder({ [this.prefix]: this, [decoder.prefix]: decoder })
+    }
+  }
+}
+
+/**
+ * @template {string} Prefix
+ * @implements {MultibaseDecoder<Prefix>}
+ */
+class ComposedDecoder {
+  /**
+   * @template {string} T
+   * @param {UnibaseDecoder<T>} decoder
+   * @returns {ComposedDecoder<T>}
+   */
+  static from (decoder) {
+    return new ComposedDecoder({ [decoder.prefix]: decoder })
+  }
+
+  /**
+   * @param {Object<Prefix, UnibaseDecoder<Prefix>>} decoders
+   */
+  constructor (decoders) {
+    /** @type {Object<string, UnibaseDecoder<Prefix>>} */
+    this.decoders = decoders
+    // so that we can distinguish between unibase and multibase
+    /** @type {void} */
+    this.prefix = null
+  }
+
+  /**
+   * @template {string} OtherPrefix
+   * @param {UnibaseDecoder<OtherPrefix>|ComposedDecoder<OtherPrefix>} decoder
+   * @returns {ComposedDecoder<Prefix|OtherPrefix>}
+   */
+  or (decoder) {
+    if (decoder instanceof ComposedDecoder) {
+      return new ComposedDecoder({ ...this.decoders, ...decoder.decoders })
+    } else {
+      return new ComposedDecoder({ ...this.decoders, [decoder.prefix]: decoder })
+    }
+  }
+
+  /**
+   * @param {string} input
+   * @returns {Uint8Array}
+   */
+  decode (input) {
+    const prefix = input[0]
+    const decoder = this.decoders[prefix]
+    if (decoder) {
+      return decoder.decode(input)
+    } else {
+      throw RangeError(`Unable to decode multibase string ${input}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`)
     }
   }
 }
@@ -191,15 +270,3 @@ export const withSettings = ({ name, prefix, settings, encode, decode }) =>
  */
 export const from = ({ name, prefix, encode, decode }) =>
   new Codec(name, prefix, encode, decode)
-
-export const notImplemented = ({ name, prefix }) =>
-  from({
-    name,
-    prefix,
-    encode: _ => {
-      throw Error(`No ${name} encoder implementation was provided`)
-    },
-    decode: _ => {
-      throw Error(`No ${name} decoder implemnetation was provided`)
-    }
-  })

src/bases/interface.ts

@@ -83,3 +83,8 @@ export interface MultibaseCodec<Prefix extends string> {
   encoder: MultibaseEncoder<Prefix>
   decoder: MultibaseDecoder<Prefix>
 }
+
+
+export interface UnibaseDecoder<Prefix extends string> extends MultibaseDecoder<Prefix> {
+  prefix: Prefix
+}

src/basics-browser.js

@@ -1,8 +1,8 @@
 // @ts-check
 
 import * as base64 from './bases/base64-browser.js'
-import { cid, CID, block, Block, hasher, digest, varint, bytes, hashes, codecs, bases as _bases } from './basics.js'
+import { CID, Block, hasher, digest, varint, bytes, hashes, codecs, bases as _bases } from './basics.js'
 
 const bases = { ..._bases, ...base64 }
 
-export { cid, CID, block, Block, hasher, digest, varint, bytes, hashes, codecs, bases }
+export { CID, Block, hasher, digest, varint, bytes, hashes, codecs, bases }

src/basics-import.js

@@ -1,6 +1,6 @@
 
-import { cid, CID, block, Block, hasher, digest, varint, bytes, hashes, codecs, bases as _bases } from './basics.js'
+import { CID, Block, hasher, digest, varint, bytes, hashes, codecs, bases as _bases } from './basics.js'
 import * as base64 from './bases/base64-import.js'
 
 const bases = { ..._bases, ...base64 }
-export { cid, CID, block, Block, hasher, digest, varint, bytes, hashes, codecs, bases }
+export { CID, Block, hasher, digest, varint, bytes, hashes, codecs, bases }

src/basics.js

@@ -1,22 +1,16 @@
 // @ts-check
 
-import { notImplemented } from './bases/base.js'
 import * as base32 from './bases/base32.js'
+import * as base58 from './bases/base58.js'
 import * as sha2 from './hashes/sha2.js'
 
 import raw from './codecs/raw.js'
 import json from './codecs/json.js'
 
-import configure from './index.js'
+import { CID, Block, hasher, digest, varint, bytes } from './index.js'
 
-const bases = { ...base32 }
+const bases = { ...base32, ...base58 }
 const hashes = { ...sha2 }
 const codecs = { raw, json }
 
-const { cid, CID, block, Block, hasher, digest, varint, bytes } = configure({
-  base: bases.base32,
-  base58btc: notImplemented({ name: 'base58btc', prefix: 'z' }),
-  hasher: hashes.sha256
-})
-
-export { cid, CID, block, Block, hasher, digest, varint, bytes, hashes, bases, codecs }
+export { CID, Block, hasher, digest, varint, bytes, hashes, bases, codecs }