format

src/ViewModel/Global/coreViewModel.ts

@@ -9,13 +9,19 @@ import ConnectionModel from "../../Model/Global/connectionModel";
 import ChatListModel from "../../Model/Chat/chatListModel";
 
 export default class CoreViewModel {
-    swRegistration: ServiceWorkerRegistration|undefined = undefined;
+    swRegistration: ServiceWorkerRegistration | undefined = undefined;
 
-    version: React.State<string>  = new React.State("");
-    latestVersion: React.State<string>  = new React.State("");
-    noUpdateAvailable: React.State<boolean> = React.createProxyState([this.latestVersion], () => {
-	return (this.latestVersion.value == "" || this.latestVersion.value == this.version.value) 
-    })
+    version: React.State<string> = new React.State("");
+    latestVersion: React.State<string> = new React.State("");
+    noUpdateAvailable: React.State<boolean> = React.createProxyState(
+        [this.latestVersion],
+        () => {
+            return (
+                this.latestVersion.value == "" ||
+                this.latestVersion.value == this.version.value
+            );
+        },
+    );
     updateText: React.State<string> = new React.State("");
 
     translations: Translations;
@@ -82,11 +88,11 @@ export default class CoreViewModel {
     };
 
     handleChron = (): void => {
-	const newDate = new Date();
-	if (this.unwrappedTodayDate.toDateString() != newDate.toDateString())
-	    this.todayDate.value = new Date();
-	if (formatTime(newDate) != this.time.value)
-	    this.time.value = formatTime(newDate);
+        const newDate = new Date();
+        if (this.unwrappedTodayDate.toDateString() != newDate.toDateString())
+            this.todayDate.value = new Date();
+        if (formatTime(newDate) != this.time.value)
+            this.time.value = formatTime(newDate);
     };
 
     // DRAG & DROP
@@ -94,75 +100,79 @@ export default class CoreViewModel {
 
     // OFFLINE MODE & UPDATE
     configureServiceWorker = async (): Promise<void> => {
-	if ("serviceWorker" in navigator) {
-	    try {
-		this.swRegistration = await navigator.serviceWorker.register(
-		    "sw.js",
-		    {
-			scope: "/",
-		    },
-		);
-		if (this.swRegistration.active) {
-		    console.log("Service worker active");
-		}
-	    } catch (error) {
-		console.error(`Could not install service worker: ${error}`);
-	    }
-	}
-    }
+        if ("serviceWorker" in navigator) {
+            try {
+                this.swRegistration = await navigator.serviceWorker.register(
+                    "sw.js",
+                    {
+                        scope: "/",
+                    },
+                );
+                if (this.swRegistration.active) {
+                    console.log("Service worker active");
+                }
+            } catch (error) {
+                console.error(`Could not install service worker: ${error}`);
+            }
+        }
+    };
 
     checkUpdates = (): void => {
-	fetch("/version").then(async response => {
-	    this.version.value = await response.text();
-	});
-	fetch("/latestVersion").then(async response => {
-	    this.latestVersion.value = (await response.text()).replace("\n", "");
-	})
-    }
+        fetch("/version").then(async (response) => {
+            this.version.value = await response.text();
+        });
+        fetch("/latestVersion").then(async (response) => {
+            this.latestVersion.value = (await response.text()).replace(
+                "\n",
+                "",
+            );
+        });
+    };
 
     update = async (): Promise<void> => {
-	if (!this.swRegistration) return;
-	await this.swRegistration.update();
-	setTimeout(()=>{
-	window.location.reload();
-	}, 500);
-    }
+        if (!this.swRegistration) return;
+        await this.swRegistration.update();
+        setTimeout(() => {
+            window.location.reload();
+        }, 500);
+    };
 
     // init
     constructor(
-	public readonly storageModel: StorageModel,
-	public readonly settingsModel: SettingsModel,
-	public readonly connectionModel: ConnectionModel,
-	public readonly chatListModel: ChatListModel,
-	public readonly fileTransferModel: FileTransferModel,
+        public readonly storageModel: StorageModel,
+        public readonly settingsModel: SettingsModel,
+        public readonly connectionModel: ConnectionModel,
+        public readonly chatListModel: ChatListModel,
+        public readonly fileTransferModel: FileTransferModel,
     ) {
-	this.translations =
-	    allTranslations[settingsModel.language] || allTranslations.en;
+        this.translations =
+            allTranslations[settingsModel.language] || allTranslations.en;
 
-	this.latestVersion.subscribe(latestVersion => {
-	    this.updateText.value = this.translations.homePage.updateButton(latestVersion);
-	});
+        this.latestVersion.subscribe((latestVersion) => {
+            this.updateText.value =
+                this.translations.homePage.updateButton(latestVersion);
+        });
 
-	document.body.addEventListener("keydown", this.handleKeyDown);
+        document.body.addEventListener("keydown", this.handleKeyDown);
 
-	window.onpopstate = () => {
-	    if (!this.context) return;
-	    this.closeContext(this.context.contextId, true);
-	};
+        window.onpopstate = () => {
+            if (!this.context) return;
+            this.closeContext(this.context.contextId, true);
+        };
 
-	this.configureServiceWorker();
-	this.checkUpdates();
+        this.configureServiceWorker();
+        this.checkUpdates();
 
-	this.startChron();
-	this.chronHandlerManager.setHandler(
-	    "core-view-model",
-	    this.handleChron,
-	);
+        this.startChron();
+        this.chronHandlerManager.setHandler(
+            "core-view-model",
+            this.handleChron,
+        );
     }
 
     // util
     static checkIsKeystroke(e: KeyboardEvent): boolean {
-	return (e.metaKey || e.altKey) && e.ctrlKey;
+        return (e.metaKey || e.altKey) && e.ctrlKey;
     }
 }
 
@@ -171,19 +181,19 @@ export class Context {
     keystrokes = new Map<string, () => void>();
 
     handleKeystroke = (e: KeyboardEvent): boolean => {
-	const fn: (() => void) | undefined = this.keystrokes.get(
-	    e.key.toLowerCase(),
-	);
-	if (!fn) return false;
-	fn();
-	return true;
+        const fn: (() => void) | undefined = this.keystrokes.get(
+            e.key.toLowerCase(),
+        );
+        if (!fn) return false;
+        fn();
+        return true;
     };
 
     close = (): void => {};
     handleContextClose = (fromHistoryEvent: boolean): void => {};
 
     registerKeyStroke = (key: string, fn: () => void): void => {
-	this.keystrokes.set(key, fn);
+        this.keystrokes.set(key, fn);
     };
 
     constructor(public contextDebugDescription: string) {}
@@ -194,45 +204,45 @@ export class ContextHost<T> extends Context {
     currentContext = new React.State<Context | undefined>(undefined);
 
     get isOpen(): boolean {
-	return false;
+        return false;
     }
     get contextSelection(): T | undefined {
-	return undefined;
+        return undefined;
     }
 
     registerContext = (key: T, context: Context): void => {
-	this.contexts.set(key, context);
+        this.contexts.set(key, context);
     };
 
     closeCurrentContext = (): void => {
-	if (this.currentContext.value) {
-	    this.coreViewModel.closeContext(
-		this.currentContext.value.contextId,
-	    );
-	}
-	this.currentContext.value = undefined;
+        if (this.currentContext.value) {
+            this.coreViewModel.closeContext(
+                this.currentContext.value.contextId,
+            );
+        }
+        this.currentContext.value = undefined;
     };
 
     updateContexts = (): void => {
-	if (this.isOpen == false) return;
+        if (this.isOpen == false) return;
 
-	const selection = this.contextSelection;
-	if (!selection) return;
-	const selectedContext: Context | undefined =
-	    this.contexts.get(selection);
-	if (!selectedContext) return;
-	if (selectedContext != this.currentContext.value) {
-	    this.closeCurrentContext();
-	}
+        const selection = this.contextSelection;
+        if (!selection) return;
+        const selectedContext: Context | undefined =
+            this.contexts.get(selection);
+        if (!selectedContext) return;
+        if (selectedContext != this.currentContext.value) {
+            this.closeCurrentContext();
+        }
 
-	this.coreViewModel.context = selectedContext;
-	this.currentContext.value = selectedContext;
+        this.coreViewModel.context = selectedContext;
+        this.currentContext.value = selectedContext;
     };
 
     constructor(
-	contextDebugDescription: string,
-	public coreViewModel: CoreViewModel,
+        contextDebugDescription: string,
+        public coreViewModel: CoreViewModel,
     ) {
-	super(contextDebugDescription);
+        super(contextDebugDescription);
     }
 }