chore(util-base64): add browser implementation

Author: trivikr

packages/util-base64/jest.config.js

@@ -2,4 +2,5 @@ const base = require("../../jest.config.base.js");
 
 module.exports = {
   ...base,
+  testMatch: ["**/*.spec.ts"],
 };

packages/util-base64/package.json

@@ -46,6 +46,14 @@
   "files": [
     "dist-*"
   ],
+  "browser": {
+    "./dist-es/fromBase64": "./dist-es/fromBase64.browser",
+    "./dist-es/toBase64": "./dist-es/toBase64.browser"
+  },
+  "react-native": {
+    "./dist-es/fromBase64": "./dist-es/fromBase64.browser",
+    "./dist-es/toBase64": "./dist-es/toBase64.browser"
+  },
   "homepage": "https://github.com/aws/aws-sdk-js-v3/tree/main/packages/util-base64",
   "repository": {
     "type": "git",

packages/util-base64/src/constants.browser.ts

@@ -0,0 +1,34 @@
+const alphabetByEncoding: Record<string, number> = {};
+const alphabetByValue: Array<string> = new Array(64);
+
+for (let i = 0, start = "A".charCodeAt(0), limit = "Z".charCodeAt(0); i + start <= limit; i++) {
+  const char = String.fromCharCode(i + start);
+  alphabetByEncoding[char] = i;
+  alphabetByValue[i] = char;
+}
+
+for (let i = 0, start = "a".charCodeAt(0), limit = "z".charCodeAt(0); i + start <= limit; i++) {
+  const char = String.fromCharCode(i + start);
+  const index = i + 26;
+  alphabetByEncoding[char] = index;
+  alphabetByValue[index] = char;
+}
+
+for (let i = 0; i < 10; i++) {
+  alphabetByEncoding[i.toString(10)] = i + 52;
+  const char = i.toString(10);
+  const index = i + 52;
+  alphabetByEncoding[char] = index;
+  alphabetByValue[index] = char;
+}
+
+alphabetByEncoding["+"] = 62;
+alphabetByValue[62] = "+";
+alphabetByEncoding["/"] = 63;
+alphabetByValue[63] = "/";
+
+const bitsPerLetter = 6;
+const bitsPerByte = 8;
+const maxLetterValue = 0b111111;
+
+export { alphabetByEncoding, alphabetByValue, bitsPerLetter, bitsPerByte, maxLetterValue };

packages/util-base64/src/fromBase64.browser.spec.ts

@@ -0,0 +1,21 @@
+/**
+ * @jest-environment jsdom
+ */
+import testCases from "./__mocks__/testCases.json";
+import { fromBase64 } from "./fromBase64.browser";
+
+describe(fromBase64.name, () => {
+  it.each(testCases as Array<[string, string, number[]]>)("%s", (desc, encoded, decoded) => {
+    expect(fromBase64(encoded)).toEqual(new Uint8Array(decoded));
+  });
+
+  it("should throw when given a number", () => {
+    expect(() => fromBase64(0xdeadbeefface as any)).toThrow();
+  });
+
+  describe("should reject invalid base64 strings", () => {
+    it.each(["Rg", "Rg=", "[][]", "-_=="])("rejects '%s'", (value) => {
+      expect(() => fromBase64(value)).toThrowError();
+    });
+  });
+});

packages/util-base64/src/fromBase64.browser.ts

@@ -0,0 +1,46 @@
+import { alphabetByEncoding, bitsPerByte, bitsPerLetter } from "./constants.browser";
+
+/**
+ * Converts a base-64 encoded string to a Uint8Array of bytes.
+ *
+ * @param input The base-64 encoded string
+ *
+ * @see https://tools.ietf.org/html/rfc4648#section-4
+ */
+export const fromBase64 = (input: string): Uint8Array => {
+  let totalByteLength = (input.length / 4) * 3;
+  if (input.slice(-2) === "==") {
+    totalByteLength -= 2;
+  } else if (input.slice(-1) === "=") {
+    totalByteLength--;
+  }
+  const out = new ArrayBuffer(totalByteLength);
+  const dataView = new DataView(out);
+  for (let i = 0; i < input.length; i += 4) {
+    let bits = 0;
+    let bitLength = 0;
+    for (let j = i, limit = i + 3; j <= limit; j++) {
+      if (input[j] !== "=") {
+        // If we don't check for this, we'll end up using undefined in a bitwise
+        // operation, in which it will be treated as 0.
+        if (!(input[j] in alphabetByEncoding)) {
+          throw new TypeError(`Invalid character ${input[j]} in base64 string.`);
+        }
+        bits |= alphabetByEncoding[input[j]] << ((limit - j) * bitsPerLetter);
+        bitLength += bitsPerLetter;
+      } else {
+        bits >>= bitsPerLetter;
+      }
+    }
+
+    const chunkOffset = (i / 4) * 3;
+    bits >>= bitLength % bitsPerByte;
+    const byteLength = Math.floor(bitLength / bitsPerByte);
+    for (let k = 0; k < byteLength; k++) {
+      const offset = (byteLength - k - 1) * bitsPerByte;
+      dataView.setUint8(chunkOffset + k, (bits & (255 << offset)) >> offset);
+    }
+  }
+
+  return new Uint8Array(out);
+};

packages/util-base64/src/toBase64.browser.spec.ts

@@ -0,0 +1,11 @@
+/**
+ * @jest-environment jsdom
+ */
+import testCases from "./__mocks__/testCases.json";
+import { toBase64 } from "./toBase64.browser";
+
+describe(toBase64.name, () => {
+  it.each(testCases as Array<[string, string, number[]]>)("%s", (desc, encoded, decoded) => {
+    expect(toBase64(new Uint8Array(decoded))).toEqual(encoded);
+  });
+});

packages/util-base64/src/toBase64.browser.ts

@@ -0,0 +1,30 @@
+import { alphabetByValue, bitsPerByte, bitsPerLetter, maxLetterValue } from "./constants.browser";
+/**
+ * Converts a Uint8Array of binary data to a base-64 encoded string.
+ *
+ * @param input The binary data to encode
+ *
+ * @see https://tools.ietf.org/html/rfc4648#section-4
+ */
+export function toBase64(input: Uint8Array): string {
+  let str = "";
+  for (let i = 0; i < input.length; i += 3) {
+    let bits = 0;
+    let bitLength = 0;
+    for (let j = i, limit = Math.min(i + 3, input.length); j < limit; j++) {
+      bits |= input[j] << ((limit - j - 1) * bitsPerByte);
+      bitLength += bitsPerByte;
+    }
+
+    const bitClusterCount = Math.ceil(bitLength / bitsPerLetter);
+    bits <<= bitClusterCount * bitsPerLetter - bitLength;
+    for (let k = 1; k <= bitClusterCount; k++) {
+      const offset = (bitClusterCount - k) * bitsPerLetter;
+      str += alphabetByValue[(bits & (maxLetterValue << offset)) >> offset];
+    }
+
+    str += "==".slice(0, 4 - bitClusterCount);
+  }
+
+  return str;
+}