Handle multiple copies of Type due to bundling

README.md

@@ -409,7 +409,7 @@ import { decode, Tokenizer, Type } from 'cborg'
 class CustomTokeniser extends Tokenizer {
   next () {
     const nextToken = super.next()
-    if (nextToken.type === Type.bytes) {
+    if (nextToken.type.equals(Type.bytes)) {
       throw new Error('Unsupported type: bytes')
     }
     return nextToken

cborg.js

@@ -2,6 +2,13 @@ import { encode } from './lib/encode.js'
 import { decode, decodeFirst, Tokeniser, tokensToObject } from './lib/decode.js'
 import { Token, Type } from './lib/token.js'
 
+// is this needed for the json module and other independ encoders
+export { encodeCustom } from './lib/encode.js'
+export { encodeErrPrefix, decodeErrPrefix } from './lib/common.js'
+export { asU8A, fromString, decodeCodePointsArray } from './lib/byte-utils.js'
+export { quickEncodeToken } from './lib/jump.js'
+export { makeCborEncoders, objectToTokens } from './lib/encode.js'
+
 /**
  * Export the types that were present in the original manual cborg.d.ts
  * @typedef {import('./interface').TagDecoder} TagDecoder
@@ -12,6 +19,10 @@ import { Token, Type } from './lib/token.js'
  */
 
 export {
+  // this is needed to prevent the bundleing trouble which happens
+  // due to the fact that token.js is used in lib/json and so in
+  // cborg/json which ends up on bundling to have two copies of token.js
+  // which will fail stmts like token.type === Type.array
   decode,
   decodeFirst,
   Tokeniser as Tokenizer,

example-bytestrings.js

@@ -92,7 +92,7 @@ tags[tagUint64Array] = uint64ArrayDecoder
 class ArrayBufferTransformingTokeniser extends Tokenizer {
   next () {
     const nextToken = super.next()
-    if (nextToken.type === Type.bytes) {
+    if (nextToken.type.equals(Type.bytes)) {
       // Transform the (assumed) Uint8Array value to an ArrayBuffer of the same bytes, note though
       // that all tags we care about are going to be <tag><bytes>, so we're also transforming those
       // into ArrayBuffers, so our tag decoders need to also assume they are getting ArrayBuffers

lib/2bytes.js

@@ -89,7 +89,7 @@ export function decodeBytes64 (data, pos, _minor, options) {
  */
 function tokenBytes (token) {
   if (token.encodedBytes === undefined) {
-    token.encodedBytes = token.type === Type.string ? fromString(token.value) : token.value
+    token.encodedBytes = token.type.equals(Type.string) ? fromString(token.value) : token.value
   }
   // @ts-ignore c'mon
   return token.encodedBytes

lib/decode.js

@@ -145,23 +145,23 @@ function tokensToObject (tokeniser, options) {
 
   const token = tokeniser.next()
 
-  if (token.type === Type.break) {
+  if (token.type.equals(Type.break)) {
     return BREAK
   }
 
   if (token.type.terminal) {
     return token.value
   }
 
-  if (token.type === Type.array) {
+  if (token.type.equals(Type.array)) {
     return tokenToArray(token, tokeniser, options)
   }
 
-  if (token.type === Type.map) {
+  if (token.type.equals(Type.map)) {
     return tokenToMap(token, tokeniser, options)
   }
 
-  if (token.type === Type.tag) {
+  if (token.type.equals(Type.tag)) {
     if (options.tags && typeof options.tags[token.value] === 'function') {
       const tagged = tokensToObject(tokeniser, options)
       return options.tags[token.value](tagged)

lib/diagnostic.js

@@ -1,4 +1,5 @@
 import { Tokeniser } from './decode.js'
+import { Type } from './token.js'
 import { toHex, fromHex } from './byte-utils.js'
 import { uintBoundaries } from './0uint.js'
 
@@ -31,25 +32,25 @@ function * tokensToDiagnostic (inp, width = 100) {
     /** @type {string|number} */
     let v = String(token.value)
     let outp = `${margin}${slc(0, 1)}`
-    const str = token.type.name === 'bytes' || token.type.name === 'string'
-    if (token.type.name === 'string') {
+    const str = token.type.equals(Type.bytes) || token.type.equals(Type.string)
+    if (token.type.equals(Type.string)) {
       v = v.length
       vLength -= v
-    } else if (token.type.name === 'bytes') {
+    } else if (token.type.equals(Type.bytes)) {
       v = token.value.length
       // @ts-ignore
       vLength -= v
     }
 
     let multilen
     switch (token.type.name) {
-      case 'string':
-      case 'bytes':
-      case 'map':
-      case 'array':
+      case Type.string.name:
+      case Type.bytes.name:
+      case Type.map.name:
+      case Type.array.name:
         // for bytes and string, we want to print out the length part of the value prefix if it
         // exists - it exists for short lengths (<24) but does for longer lengths
-        multilen = token.type.name === 'string' ? utf8Encoder.encode(token.value).length : token.value.length
+        multilen = token.type.equals(Type.string) ? utf8Encoder.encode(token.value).length : token.value.length
         if (multilen >= uintBoundaries[0]) {
           if (multilen < uintBoundaries[1]) {
             outp += ` ${slc(1, 1)}`
@@ -71,13 +72,14 @@ function * tokensToDiagnostic (inp, width = 100) {
 
     outp = outp.padEnd(width / 2, ' ')
     outp += `# ${margin}${token.type.name}`
+    // there should be a method to get a Type from a String
     if (token.type.name !== v) {
       outp += `(${v})`
     }
     yield outp
 
     if (str) {
-      let asString = token.type.name === 'string'
+      let asString = token.type.equals(Type.string)
       margin += '  '
       let repr = asString ? utf8Encoder.encode(token.value) : token.value
       if (asString && token.byteValue !== undefined) {
@@ -110,15 +112,15 @@ function * tokensToDiagnostic (inp, width = 100) {
     }
     if (!token.type.terminal) {
       switch (token.type.name) {
-        case 'map':
+        case Type.map.name:
           indent.push(token.value * 2)
           break
-        case 'array':
+        case Type.array.name:
           indent.push(token.value)
           break
         // TODO: test tags .. somehow
         /* c8 ignore next 5 */
-        case 'tag':
+        case Type.tag.name:
           indent.push(1)
           break
         default:

lib/json/decode.js

@@ -1,7 +1,9 @@
-import { decode as _decode, decodeFirst as _decodeFirst } from '../decode.js'
-import { Token, Type } from '../token.js'
-import { decodeCodePointsArray } from '../byte-utils.js'
-import { decodeErrPrefix } from '../common.js'
+// never reference the file directly to ensure the
+// indepency of the json module
+import { decode as _decode, decodeFirst as _decodeFirst } from 'cborg'
+import { Token, Type } from 'cborg'
+import { decodeCodePointsArray } from 'cborg'
+import { decodeErrPrefix } from 'cborg'
 
 /**
  * @typedef {import('../../interface').DecodeOptions} DecodeOptions