implement auto reconnect

src/Model/Utility/crypto.ts

@@ -3,113 +3,113 @@ const ENCRYPTION_ALG = "AES-GCM";
 
 // minimal
 export async function encryptString(
-  plaintext: string,
-  passphrase: string
+    plaintext: string,
+    passphrase: string,
 ): Promise<string> {
-  if (!window.crypto.subtle) return plaintext;
+    if (!window.crypto.subtle) return plaintext;
 
-  const iv = generateIV();
-  const key = await importKey(passphrase, "encrypt");
-  const encryptedArray = await encrypt(iv, key, plaintext);
+    const iv = generateIV();
+    const key = await importKey(passphrase, "encrypt");
+    const encryptedArray = await encrypt(iv, key, plaintext);
 
-  const encryptionData = {
-    iv: uInt8ToArray(iv),
-    encryptedArray: uInt8ToArray(encryptedArray),
-  };
-  return btoa(JSON.stringify(encryptionData));
+    const encryptionData = {
+        iv: uInt8ToArray(iv),
+        encryptedArray: uInt8ToArray(encryptedArray),
+    };
+    return btoa(JSON.stringify(encryptionData));
 }
 
 export async function decryptString(
-  cyphertext: string,
-  passphrase: string
+    cyphertext: string,
+    passphrase: string,
 ): Promise<string> {
-  try {
-    const encrypionData = JSON.parse(atob(cyphertext));
-    const iv = arrayToUint8(encrypionData.iv);
-    const encryptedArray = arrayToUint8(encrypionData.encryptedArray);
+    try {
+        const encrypionData = JSON.parse(atob(cyphertext));
+        const iv = arrayToUint8(encrypionData.iv);
+        const encryptedArray = arrayToUint8(encrypionData.encryptedArray);
 
-    const key = await importKey(passphrase, "decrypt");
-    return await decrypt(iv, key, encryptedArray);
-  } catch {
-    return cyphertext;
-  }
+        const key = await importKey(passphrase, "decrypt");
+        return await decrypt(iv, key, encryptedArray);
+    } catch {
+        return cyphertext;
+    }
 }
 
 // process
 export function encode(string: string): Uint8Array {
-  return new TextEncoder().encode(string);
+    return new TextEncoder().encode(string);
 }
 
 export function decode(array: Uint8Array): string {
-  return new TextDecoder("utf-8").decode(array);
+    return new TextDecoder("utf-8").decode(array);
 }
 
 export async function encrypt(
-  iv: Uint8Array,
-  key: CryptoKey,
-  message: string
+    iv: Uint8Array,
+    key: CryptoKey,
+    message: string,
 ): Promise<Uint8Array> {
-  const arrayBuffer = await window.crypto.subtle.encrypt(
-    { name: ENCRYPTION_ALG, iv },
-    key,
-    encode(message)
-  );
-  return new Uint8Array(arrayBuffer);
+    const arrayBuffer = await window.crypto.subtle.encrypt(
+        { name: ENCRYPTION_ALG, iv },
+        key,
+        encode(message),
+    );
+    return new Uint8Array(arrayBuffer);
 }
 
 export async function decrypt(
-  iv: Uint8Array,
-  key: CryptoKey,
-  cyphertext: Uint8Array
+    iv: Uint8Array,
+    key: CryptoKey,
+    cyphertext: Uint8Array,
 ): Promise<string> {
-  const arrayBuffer = await crypto.subtle.decrypt(
-    { name: ENCRYPTION_ALG, iv },
-    key,
-    cyphertext
-  );
-  return arrayBufferToString(arrayBuffer);
+    const arrayBuffer = await crypto.subtle.decrypt(
+        { name: ENCRYPTION_ALG, iv },
+        key,
+        cyphertext,
+    );
+    return arrayBufferToString(arrayBuffer);
 }
 
 export async function hash(encoded: Uint8Array): Promise<ArrayBuffer> {
-  return await crypto.subtle.digest("SHA-256", encoded);
+    return await crypto.subtle.digest("SHA-256", encoded);
 }
 
 // iv
 export function generateIV(): Uint8Array {
-  return crypto.getRandomValues(new Uint8Array(IV_SIZE));
+    return crypto.getRandomValues(new Uint8Array(IV_SIZE));
 }
 
 export function splitMergedString(mergedString: string): [Uint8Array, string] {
-  const iv = mergedString.slice(0, IV_SIZE);
-  const encryptedString = mergedString.slice(IV_SIZE);
+    const iv = mergedString.slice(0, IV_SIZE);
+    const encryptedString = mergedString.slice(IV_SIZE);
 
-  return [JSON.parse(iv), encryptedString];
+    return [JSON.parse(iv), encryptedString];
 }
 
 // key
 export async function importKey(
-  passphrase: string,
-  purpose: "encrypt" | "decrypt"
+    passphrase: string,
+    purpose: "encrypt" | "decrypt",
 ): Promise<CryptoKey> {
-  return await crypto.subtle.importKey(
-    "raw",
-    await hash(encode(passphrase)),
-    { name: ENCRYPTION_ALG },
-    false,
-    [purpose]
-  );
+    return await crypto.subtle.importKey(
+        "raw",
+        await hash(encode(passphrase)),
+        { name: ENCRYPTION_ALG },
+        false,
+        [purpose],
+    );
 }
 
 // conversion
 export function arrayBufferToString(arrayBuffer: ArrayBuffer): string {
-  const uInt8Array = new Uint8Array(arrayBuffer);
-  return decode(uInt8Array);
+    const uInt8Array = new Uint8Array(arrayBuffer);
+    return decode(uInt8Array);
 }
 
 export function uInt8ToArray(uInt8Array: Uint8Array): number[] {
-  return Array.from(uInt8Array);
+    return Array.from(uInt8Array);
 }
 
 export function arrayToUint8(array: number[]): Uint8Array {
-  return new Uint8Array(array);
+    return new Uint8Array(array);
 }