refactor: Remove base64 function overloading

Signed-off-by: Lukas <Lukas@hopae.io>

Author: lukasjhan

src/base64url.ts

@@ -1,16 +1,8 @@
 import { Base64 } from 'js-base64';
 
-const encode = (input: string): string => Base64.encodeURI(input);
+export const Base64urlEncode = Base64.encodeURI;
 
-const decode = (input: string): string => {
-  return Base64.decode(input);
-};
+export const Base64urlDecode = Base64.decode;
 
-const Uint8ArrayToBase64Url = (input: Uint8Array): string =>
+export const Uint8ArrayToBase64Url = (input: Uint8Array): string =>
   Base64.fromUint8Array(input, true);
-
-export const Base64Url = {
-  encode,
-  decode,
-  Uint8ArrayToBase64Url,
-};

src/decoy.ts

@@ -1,5 +1,5 @@
 import { HasherAndAlg, SaltGenerator } from './type';
-import { Base64Url } from './base64url';
+import { Uint8ArrayToBase64Url } from './base64url';
 
 export const createDecoy = async (
   hash: HasherAndAlg,
@@ -8,5 +8,5 @@ export const createDecoy = async (
   const { hasher, alg } = hash;
   const salt = await saltGenerator(16);
   const decoy = await hasher(salt, alg);
-  return Base64Url.Uint8ArrayToBase64Url(decoy);
+  return Uint8ArrayToBase64Url(decoy);
 };

src/disclosure.ts

@@ -1,4 +1,8 @@
-import { Base64Url } from './base64url';
+import {
+  Uint8ArrayToBase64Url,
+  Base64urlDecode,
+  Base64urlEncode,
+} from './base64url';
 import { SDJWTException } from './error';
 import { HasherAndAlg } from './type';
 
@@ -32,8 +36,8 @@ export class Disclosure<T> {
   public static async fromEncode<T>(s: string, hash: HasherAndAlg) {
     const { hasher, alg } = hash;
     const digest = await hasher(s, alg);
-    const digestStr = Base64Url.Uint8ArrayToBase64Url(digest);
-    const item = JSON.parse(Base64Url.decode(s)) as DisclosureData<T>;
+    const digestStr = Uint8ArrayToBase64Url(digest);
+    const item = JSON.parse(Base64urlDecode(s)) as DisclosureData<T>;
     return Disclosure.fromArray<T>(item, digestStr);
   }
 
@@ -42,7 +46,7 @@ export class Disclosure<T> {
   }
 
   public encode() {
-    return Base64Url.encode(JSON.stringify(this.decode()));
+    return Base64urlEncode(JSON.stringify(this.decode()));
   }
 
   public decode(): DisclosureData<T> {
@@ -55,7 +59,7 @@ export class Disclosure<T> {
     const { hasher, alg } = hash;
     if (!this._digest) {
       const hash = await hasher(this.encode(), alg);
-      this._digest = Base64Url.Uint8ArrayToBase64Url(hash);
+      this._digest = Uint8ArrayToBase64Url(hash);
     }
 
     return this._digest;

src/jwt.ts

@@ -1,4 +1,4 @@
-import { Base64Url } from './base64url';
+import { Base64urlDecode, Base64urlEncode } from './base64url';
 import { SDJWTException } from './error';
 import { Base64urlString, Signer, Verifier } from './type';
 
@@ -37,8 +37,8 @@ export class Jwt<
     }
 
     return {
-      header: JSON.parse(Base64Url.decode(header)),
-      payload: JSON.parse(Base64Url.decode(payload)),
+      header: JSON.parse(Base64urlDecode(header)),
+      payload: JSON.parse(Base64urlDecode(payload)),
       signature: signature,
     };
   }
@@ -75,8 +75,8 @@ export class Jwt<
       throw new SDJWTException('Sign Error: Invalid JWT');
     }
 
-    const header = Base64Url.encode(JSON.stringify(this.header));
-    const payload = Base64Url.encode(JSON.stringify(this.payload));
+    const header = Base64urlEncode(JSON.stringify(this.header));
+    const payload = Base64urlEncode(JSON.stringify(this.payload));
     const data = `${header}.${payload}`;
     this.signature = await signer(data);
 
@@ -88,8 +88,8 @@ export class Jwt<
       throw new SDJWTException('Serialize Error: Invalid JWT');
     }
 
-    const header = Base64Url.encode(JSON.stringify(this.header));
-    const payload = Base64Url.encode(JSON.stringify(this.payload));
+    const header = Base64urlEncode(JSON.stringify(this.header));
+    const payload = Base64urlEncode(JSON.stringify(this.payload));
     const signature = this.signature;
     const compact = `${header}.${payload}.${signature}`;
 
@@ -101,8 +101,8 @@ export class Jwt<
       throw new SDJWTException('Verify Error: Invalid JWT');
     }
 
-    const header = Base64Url.encode(JSON.stringify(this.header));
-    const payload = Base64Url.encode(JSON.stringify(this.payload));
+    const header = Base64urlEncode(JSON.stringify(this.header));
+    const payload = Base64urlEncode(JSON.stringify(this.payload));
     const data = `${header}.${payload}`;
 
     const verified = verifier(data, this.signature);

src/test/base64url.spec.ts

@@ -1,23 +1,25 @@
-import { Base64Url } from '../base64url';
+import {
+  Base64urlDecode,
+  Base64urlEncode,
+  Uint8ArrayToBase64Url,
+} from '../base64url';
 
 describe('Base64url', () => {
   const raw = 'abcdefghijklmnopqrstuvwxyz';
   const encoded = 'YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXo';
   test('Encode', () => {
-    expect(Base64Url.encode(raw)).toStrictEqual(encoded);
+    expect(Base64urlEncode(raw)).toStrictEqual(encoded);
   });
   test('Decode', () => {
-    expect(Base64Url.decode(encoded)).toStrictEqual(raw);
+    expect(Base64urlDecode(encoded)).toStrictEqual(raw);
   });
   test('Encode and decode', () => {
     const str = 'hello world';
-    expect(Base64Url.decode(Base64Url.encode(str))).toStrictEqual(str);
+    expect(Base64urlDecode(Base64urlEncode(str))).toStrictEqual(str);
   });
   test('Uint8Array', () => {
     const str = 'hello world';
     const uint8 = new TextEncoder().encode(str);
-    expect(Base64Url.Uint8ArrayToBase64Url(uint8)).toStrictEqual(
-      Base64Url.encode(str),
-    );
+    expect(Uint8ArrayToBase64Url(uint8)).toStrictEqual(Base64urlEncode(str));
   });
 });

src/test/decoy.spec.ts

@@ -1,5 +1,5 @@
 import { createDecoy } from '../decoy';
-import { Base64Url } from '../base64url';
+import { Base64urlEncode } from '../base64url';
 import { digest, generateSalt } from './crypto.spec';
 
 const hash = {
@@ -20,7 +20,7 @@ describe('Decoy', () => {
   //  *  Contents: ["6Ij7tM-a5iVPGboS5tmvVA", "email", "johndoe@example.com"]
   test('apply hasher and saltGenerator', async () => {
     const decoyValue = await createDecoy(hash, () =>
-      Base64Url.encode(
+      Base64urlEncode(
         '["6Ij7tM-a5iVPGboS5tmvVA", "email", "johndoe@example.com"]',
       ),
     );

src/test/disclosure.spec.ts

@@ -1,7 +1,7 @@
 import { generateSalt, digest as hasher } from './crypto.spec';
 import { Disclosure } from '../disclosure';
 import { SDJWTException } from '../error';
-import { Base64Url } from '../base64url';
+import { Base64urlEncode } from '../base64url';
 
 const hash = { alg: 'SHA256', hasher };
 
@@ -115,7 +115,7 @@ describe('Disclosure', () => {
   });
 
   test('digest disclosure #2', async () => {
-    const encoded = Base64Url.encode(TestDataDraft7.claimTests[0].contents);
+    const encoded = Base64urlEncode(TestDataDraft7.claimTests[0].contents);
     expect(encoded).toStrictEqual(TestDataDraft7.claimTests[0].disclosure);
 
     const disclosure = await Disclosure.fromEncode(