Encode strings as UTF-8 before/after converting to base64 (#362)

* Add test that catches error

* Even simpler test

* Steal goog.crypt UTF8 encoding

* [AUTOMATED]: Prettier Code Styling

* More test cases

Author: ryanpbrewster

packages/util/src/crypt.ts

@@ -15,17 +15,34 @@
  */
 
 const stringToByteArray = function(str) {
-  var output = [],
+  // TODO(user): Use native implementations if/when available
+  var out = [],
     p = 0;
   for (var i = 0; i < str.length; i++) {
     var c = str.charCodeAt(i);
-    while (c > 255) {
-      output[p++] = c & 255;
-      c >>= 8;
+    if (c < 128) {
+      out[p++] = c;
+    } else if (c < 2048) {
+      out[p++] = (c >> 6) | 192;
+      out[p++] = (c & 63) | 128;
+    } else if (
+      (c & 0xfc00) == 0xd800 &&
+      i + 1 < str.length &&
+      (str.charCodeAt(i + 1) & 0xfc00) == 0xdc00
+    ) {
+      // Surrogate Pair
+      c = 0x10000 + ((c & 0x03ff) << 10) + (str.charCodeAt(++i) & 0x03ff);
+      out[p++] = (c >> 18) | 240;
+      out[p++] = ((c >> 12) & 63) | 128;
+      out[p++] = ((c >> 6) & 63) | 128;
+      out[p++] = (c & 63) | 128;
+    } else {
+      out[p++] = (c >> 12) | 224;
+      out[p++] = ((c >> 6) & 63) | 128;
+      out[p++] = (c & 63) | 128;
     }
-    output[p++] = c;
   }
-  return output;
+  return out;
 };
 
 /**
@@ -35,23 +52,36 @@ const stringToByteArray = function(str) {
  * @return {string} Stringification of the array.
  */
 const byteArrayToString = function(bytes) {
-  var CHUNK_SIZE = 8192;
-
-  // Special-case the simple case for speed's sake.
-  if (bytes.length < CHUNK_SIZE) {
-    return String.fromCharCode.apply(null, bytes);
-  }
-
-  // The remaining logic splits conversion by chunks since
-  // Function#apply() has a maximum parameter count.
-  // See discussion: http://goo.gl/LrWmZ9
-
-  var str = '';
-  for (var i = 0; i < bytes.length; i += CHUNK_SIZE) {
-    var chunk = bytes.slice(i, i + CHUNK_SIZE);
-    str += String.fromCharCode.apply(null, chunk);
+  // TODO(user): Use native implementations if/when available
+  var out = [],
+    pos = 0,
+    c = 0;
+  while (pos < bytes.length) {
+    var c1 = bytes[pos++];
+    if (c1 < 128) {
+      out[c++] = String.fromCharCode(c1);
+    } else if (c1 > 191 && c1 < 224) {
+      var c2 = bytes[pos++];
+      out[c++] = String.fromCharCode(((c1 & 31) << 6) | (c2 & 63));
+    } else if (c1 > 239 && c1 < 365) {
+      // Surrogate Pair
+      var c2 = bytes[pos++];
+      var c3 = bytes[pos++];
+      var c4 = bytes[pos++];
+      var u =
+        (((c1 & 7) << 18) | ((c2 & 63) << 12) | ((c3 & 63) << 6) | (c4 & 63)) -
+        0x10000;
+      out[c++] = String.fromCharCode(0xd800 + (u >> 10));
+      out[c++] = String.fromCharCode(0xdc00 + (u & 1023));
+    } else {
+      var c2 = bytes[pos++];
+      var c3 = bytes[pos++];
+      out[c++] = String.fromCharCode(
+        ((c1 & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63)
+      );
+    }
   }
-  return str;
+  return out.join('');
 };
 
 // Static lookup maps, lazily populated by init_()

packages/util/test/base64.test.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2017 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { assert } from 'chai';
+import { base64Encode, base64Decode } from '../src/crypt';
+
+describe('base64', () => {
+  it('bijective', () => {
+    let cases = [ '$', '¢', '€', '𐍈' ]; // 1, 2, 3, and 4 byte characters
+    cases.forEach(str => {
+      assert.strictEqual(base64Decode(base64Encode(str)), str);
+    });
+  });
+});