feat: make Base32 browser compatible

— Remove dependency on Node's Buffer and switch to Uint8Array for byte handling
and TextDecoder for string decoding, with a globalThis.Buffer fallback for Node
environments.

Signed-off-by: Chen Su <ghosind@gmail.com>

Author: ghosind

package-lock.json

@@ -1,5 +1,5 @@
 /* eslint-disable no-bitwise */
-import { checkEncoder, checkPadChar } from './utils';
+import { checkEncoder, checkPadChar, decodeBytes } from './utils';
 
 /**
  * The standard Base32 encoding alphabets.
@@ -82,7 +82,7 @@ export class Base32Encoding {
 
     const { encoder, padChar } = this.getEncoderAndPadChar(options);
     const destLen = this.getEncodeLength(data.length, padChar);
-    const dest = Buffer.alloc(destLen, padChar);
+    const dest = new Uint8Array(destLen);
 
     let bits = 0;
     let value = 0;
@@ -93,25 +93,25 @@ export class Base32Encoding {
       bits += 8;
 
       while (bits >= 5) {
-        dest.writeUInt8(encoder[(value >>> (bits - 5)) & 31].charCodeAt(0), offset);
+        dest[offset] = encoder[(value >>> (bits - 5)) & 31].charCodeAt(0);
         offset++;
         bits -= 5;
       }
     }
 
     if (bits > 0) {
-      dest.writeUInt8(encoder[(value << (5 - bits)) & 31].charCodeAt(0), offset);
+      dest[offset] = encoder[(value << (5 - bits)) & 31].charCodeAt(0);
       offset++;
     }
 
     if (padChar !== '') {
       while (offset < destLen) {
-        dest.writeUInt8(padChar.charCodeAt(0), offset);
+        dest[offset] = padChar.charCodeAt(0);
         offset++;
       }
     }
 
-    return dest.toString();
+    return decodeBytes(dest);
   }
 
   /**
@@ -133,7 +133,7 @@ export class Base32Encoding {
 
     const { encoder, padChar } = this.getEncoderAndPadChar(options);
     const [cleanedLength, destLen] = this.getDecodeLength(str, padChar);
-    const dest = Buffer.alloc(destLen);
+    const dest = new Uint8Array(destLen);
 
     let bits = 0;
     let value = 0;
@@ -149,13 +149,13 @@ export class Base32Encoding {
       bits += 5;
 
       if (bits >= 8) {
-        dest.writeUInt8((value >>> (bits - 8)) & 0xff, offset);
+        dest[offset] = (value >>> (bits - 8)) & 0xff;
         offset++;
         bits -= 8;
       }
     }
 
-    return dest.toString();
+    return decodeBytes(dest);
   }
 
   /**

src/base32.ts

@@ -56,3 +56,21 @@ export const checkPadChar = (padChar: string): string | undefined => {
 
   return padding;
 };
+
+/**
+ * Decode the Uint8Array bytes to string.
+ *
+ * @param bytes The bytes to decode.
+ * @returns The decoded string.
+ */
+export const decodeBytes = (bytes: Uint8Array): string => {
+  if (typeof TextDecoder !== 'undefined') {
+    return new TextDecoder().decode(bytes);
+  }
+
+  if (typeof globalThis.Buffer !== 'undefined') {
+    return globalThis.Buffer.from(bytes).toString();
+  }
+
+  return Array.from(bytes).map((b) => String.fromCharCode(b)).join('');
+}

src/utils.ts

@@ -2,7 +2,7 @@ import assert from 'assert';
 import { describe, it } from 'mocha';
 
 import { Base32StdEncoder } from '../src/base32';
-import { checkEncoder, checkPadChar } from '../src/utils';
+import { checkEncoder, checkPadChar, decodeBytes } from '../src/utils';
 
 describe('Test check encoder', () => {
   it('Test check encoder', () => {
@@ -64,3 +64,45 @@ describe('Test check pad char', () => {
     });
   });
 });
+
+describe('Test decode bytes', () => {
+  const data = new Uint8Array([72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33]); // "Hello, World!"
+  const expected = "Hello, World!";
+
+  it('Test decode bytes with default TextDecoder', () => {
+    const str = decodeBytes(data);
+    assert.equal(str, expected);
+  });
+
+  it('Test decode bytes with Node.js Buffer', () => {
+    const original = global.TextDecoder;
+
+    try {
+      // @ts-ignore
+      global.TextDecoder = undefined;
+
+      const str = decodeBytes(data);
+      assert.equal(str, expected);
+    } finally {
+      global.TextDecoder = original;
+    }
+  });
+
+  it('Test decode bytes with convert fromCharCode', () => {
+    const originalTextDecoder = global.TextDecoder;
+    const originalBuffer = global.Buffer;
+
+    try {
+      // @ts-ignore
+      global.TextDecoder = undefined;
+      // @ts-ignore
+      global.Buffer = undefined;
+
+      const str = decodeBytes(data);
+      assert.equal(str, expected);
+    } finally {
+      global.TextDecoder = originalTextDecoder;
+      global.Buffer = originalBuffer;
+    }
+  });
+});