feat(base64): allow for decode as hexstring

Author: Per Kristian Kummermo

package-lock.json

@@ -63,5 +63,9 @@
     "hooks": {
       "commit-msg": "validate-commit-msg"
     }
+  },
+  "dependencies": {
+    "@types/base64-js": "1.2.5",
+    "base64-js": "1.3.0"
   }
 }

package.json

@@ -33,7 +33,22 @@ export enum Base64Action {
   DECODE = "decode",
 }
 
+/**
+ * Base64DecodeAs used as config parameter
+ */
+export enum Base64DecodeAs {
+  /**
+   * Config parameter for defining decoding as string
+   */
+  STRING = "string",
+  /**
+   * Config parameter for definint decoding as hex string
+   */
+  HEXSTRING = "hexstring",
+}
+
 export const Config = {
   Base64Action,
+  Base64DecodeAs,
   Endianness,
 };

src/Config.ts

@@ -1,11 +1,14 @@
-import { Base64Action } from "../Config";
+import { Base64Action, Base64DecodeAs } from "../Config";
 import { Base64 } from "./Base64";
 
 describe("Base64 mapper", () => {
   let base64: Base64;
   const helloWorldBase64: string = "aGVsbG8gd29ybGQ=";
   const helloWorldString: string = "hello world";
 
+  const hexBase64: string = "SAHkwD45wbQ/jbR0Qc5mZkGSiIA/MjQAAAHLAIAAA+K0AAIAAw==";
+  const hexString: string = "4801e4c03e39c1b43f8db47441ce6666419288803f3234000001cb00800003e2b400020003";
+
   beforeEach(() => {
     base64 = new Base64();
   });
@@ -24,6 +27,15 @@ describe("Base64 mapper", () => {
 
       expect(transformRes).toEqual(helloWorldString);
     });
+
+    it("should correctly decode a base 64 hexstring given", () => {
+      base64.action = Base64Action.DECODE;
+      base64.decodeAs = Base64DecodeAs.HEXSTRING;
+
+      const transformRes = base64.transform(hexBase64);
+
+      expect(transformRes).toEqual(hexString);
+    });
   });
 
   describe("Configuration", () => {
@@ -36,6 +48,7 @@ describe("Base64 mapper", () => {
         id: "BASE64",
         params: {
           action: Base64Action.ENCODE,
+          decodeAs: Base64DecodeAs.STRING,
         },
       });
     });

src/mappers/Base64.spec.ts

@@ -1,8 +1,10 @@
-import { Base64Action } from "../Config";
+import * as base64js from "base64-js";
+import { Base64Action, Base64DecodeAs } from "../Config";
 import { IDataValue, IMapper, IMapperConfig, IOutputType } from "./../Typings";
 
 export interface IBase64Config {
   action?: Base64Action;
+  decodeAs?: Base64DecodeAs;
 }
 
 export class Base64 implements IMapper {
@@ -13,18 +15,22 @@ export class Base64 implements IMapper {
   outputType: IOutputType = IOutputType.string;
 
   action: Base64Action = Base64Action.DECODE;
+  decodeAs: Base64DecodeAs = Base64DecodeAs.STRING;
 
   constructor({
     action = Base64Action.DECODE,
+    decodeAs = Base64DecodeAs.STRING,
   }: IBase64Config = {}) {
     this.action = action;
+    this.decodeAs = decodeAs;
   }
 
   config(): IMapperConfig {
     return {
       id: Base64.id,
       params: {
         action: this.action,
+        decodeAs: this.decodeAs,
       },
     };
   }
@@ -34,20 +40,29 @@ export class Base64 implements IMapper {
       return data;
     }
 
-    let resString = data.toString();
+    let resString: string = data as string;
 
     if (this.action === Base64Action.DECODE) {
       try {
-        resString = window.atob(resString);
+        const uintArr = base64js.toByteArray(data as string);
+
+        if (this.decodeAs === Base64DecodeAs.STRING) {
+          return String.fromCharCode.apply(null, uintArr as any);
+        } else if (this.decodeAs === Base64DecodeAs.HEXSTRING) {
+          return Array.from(uintArr, (byte: number) => {
+            return ("0" + (byte & 0xFF).toString(16)).slice(-2);
+          }).join("");
+        }
       } catch (e) {
-        return data;
+        return resString;
       }
     }
+
     if (this.action === Base64Action.ENCODE) {
       try {
         resString = window.btoa(resString);
       } catch (e) {
-        return data;
+        return resString;
       }
     }