2.3.8

package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-token-auth",
-  "version": "2.3.6",
+  "version": "2.3.8",
   "description": "React Token Auth",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

src/isTokenExpired.ts

@@ -1,5 +1,6 @@
 import { SimpleLogger } from './logger';
 import { Maybe, TokenString } from './types';
+import { Base64 } from './utils/base64';
 
 export const isTokenExpired = (token: TokenString, thresholdMillisec?: number, logger?: SimpleLogger) =>
     isTimestampExpired(jwtExp(token, logger), thresholdMillisec, logger);
@@ -13,8 +14,7 @@ const jwtExp = (token: string, logger?: SimpleLogger): number | null => {
     }
 
     try {
-        const middlePart = atob(token.split('.')[1]);
-        // const middlePart = Buffer.from(token.split('.')[1], 'base64').toString();
+        const middlePart = Base64.decode(token.split('.')[1]);
         logger?.log('jwtExp', 'middlePart', middlePart);
         const jwt = JSON.parse(middlePart);
         logger?.log('jwtExp', 'jwt', jwt);
@@ -24,6 +24,8 @@ const jwtExp = (token: string, logger?: SimpleLogger): number | null => {
             return null;
         }
     } catch (e) {
+        // tslint:disable-next-line:no-console
+        console.warn(e);
         return null;
     }
 };

src/utils/base64.d.ts

@@ -0,0 +1 @@
+export const Base64: { decode: (input: string) => string };

src/utils/base64.js

@@ -0,0 +1,132 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Base64 encode / decode
+ * http://www.webtoolkit.info/
+ **/
+var Base64 = {
+    // private property
+    _keyStr: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',
+
+    // public method for encoding
+    encode: function (input) {
+        var output = '';
+        var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
+        var i = 0;
+
+        input = Base64._utf8_encode(input);
+
+        while (i < input.length) {
+            chr1 = input.charCodeAt(i++);
+            chr2 = input.charCodeAt(i++);
+            chr3 = input.charCodeAt(i++);
+
+            enc1 = chr1 >> 2;
+            enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
+            enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
+            enc4 = chr3 & 63;
+
+            if (isNaN(chr2)) {
+                enc3 = enc4 = 64;
+            } else if (isNaN(chr3)) {
+                enc4 = 64;
+            }
+
+            output =
+                output +
+                this._keyStr.charAt(enc1) +
+                this._keyStr.charAt(enc2) +
+                this._keyStr.charAt(enc3) +
+                this._keyStr.charAt(enc4);
+        }
+        return output;
+    },
+
+    // public method for decoding
+    decode: function (input) {
+        var output = '';
+        var chr1, chr2, chr3;
+        var enc1, enc2, enc3, enc4;
+        var i = 0;
+
+        input = input.replace(/[^A-Za-z0-9\+\/\=]/g, '');
+
+        while (i < input.length) {
+            enc1 = this._keyStr.indexOf(input.charAt(i++));
+            enc2 = this._keyStr.indexOf(input.charAt(i++));
+            enc3 = this._keyStr.indexOf(input.charAt(i++));
+            enc4 = this._keyStr.indexOf(input.charAt(i++));
+
+            chr1 = (enc1 << 2) | (enc2 >> 4);
+            chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+            chr3 = ((enc3 & 3) << 6) | enc4;
+
+            output = output + String.fromCharCode(chr1);
+
+            if (enc3 != 64) {
+                output = output + String.fromCharCode(chr2);
+            }
+            if (enc4 != 64) {
+                output = output + String.fromCharCode(chr3);
+            }
+        }
+
+        output = Base64._utf8_decode(output);
+
+        return output;
+    },
+
+    // private method for UTF-8 encoding
+    _utf8_encode: function (string) {
+        string = string.replace(/\r\n/g, '\n');
+        var utftext = '';
+
+        for (var n = 0; n < string.length; n++) {
+            var c = string.charCodeAt(n);
+
+            if (c < 128) {
+                utftext += String.fromCharCode(c);
+            } else if (c > 127 && c < 2048) {
+                utftext += String.fromCharCode((c >> 6) | 192);
+                utftext += String.fromCharCode((c & 63) | 128);
+            } else {
+                utftext += String.fromCharCode((c >> 12) | 224);
+                utftext += String.fromCharCode(((c >> 6) & 63) | 128);
+                utftext += String.fromCharCode((c & 63) | 128);
+            }
+        }
+        return utftext;
+    },
+
+    // private method for UTF-8 decoding
+    _utf8_decode: function (utftext) {
+        var string = '';
+        var i = 0;
+        var c1 = 0;
+        var c2 = 0;
+        var c = 0;
+
+        while (i < utftext.length) {
+            c = utftext.charCodeAt(i);
+
+            if (c < 128) {
+                string += String.fromCharCode(c);
+                i++;
+            } else if (c > 191 && c < 224) {
+                c2 = utftext.charCodeAt(i + 1);
+                string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
+                i += 2;
+            } else {
+                c2 = utftext.charCodeAt(i + 1);
+                c3 = utftext.charCodeAt(i + 2);
+                string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
+                i += 3;
+            }
+        }
+        return string;
+    },
+};
+
+module.exports = { Base64 };

tsconfig.json

@@ -1,20 +1,13 @@
 {
-  "compilerOptions": {
-    "target": "es5",
-    "module": "commonjs",
-    "declaration": true,
-    "outDir": "./lib",
-    "strict": true,
-    "lib": [
-      "dom",
-      "es6"
-    ]
-  },
-  "include": [
-    "src"
-  ],
-  "exclude": [
-    "node_modules",
-    "**/__tests__/*"
-  ]
-}
+    "compilerOptions": {
+        "target": "es5",
+        "module": "commonjs",
+        "declaration": true,
+        "outDir": "./lib",
+        "strict": true,
+        "allowJs": true,
+        "lib": ["dom", "es6"]
+    },
+    "include": ["src"],
+    "exclude": ["node_modules", "**/__tests__/*"]
+}

tslint.json

@@ -1,6 +1,3 @@
 {
-  "extends": [
-    "tslint:recommended",
-    "tslint-config-prettier"
-  ]
-}
+    "extends": ["tslint:recommended", "tslint-config-prettier"]
+}