init type updates

Author: MathMan05

src/webpage/app.html

@@ -147,6 +147,7 @@ <h2 id="serverName" class="ellipsis">Server Name</h2>
 	</body>
 	<script src="/index.js" type="module"></script>
 	<!-- <script src="/service.js" --->
+	<!-- <script src="/typeChecker/chekerIndex.js" --->
 	<!-- <script src="/audio/worklet/worklet.js" --->
 	<!-- <script src="/utils/dirrWorker.js" --->
 </html>

src/webpage/index.ts

@@ -18,13 +18,25 @@ import "./oauth2/auth.js";
 import "./audio/page.js";
 import "./404.js";
 import {Channel} from "./channel.js";
+import type * as C from "./typeChecker/chekerIndex.js";
 
 if (window.location.pathname === "/app") {
 	window.location.pathname = "/channels/@me";
 }
 export interface CustomHTMLDivElement extends HTMLDivElement {
 	markdown: MarkDown;
 }
+declare global {
+	interface Window {
+		checker?: typeof C.Check;
+	}
+}
+if (localStorage.getItem("checkTypes")) {
+	const i = (await import(
+		"/typeChecker/chekerIndex.js" as "./typeChecker/chekerIndex.js"
+	)) as typeof C;
+	window.checker = i.Check;
+}
 if (window.location.pathname.startsWith("/channels")) {
 	let templateID = new URLSearchParams(window.location.search).get("templateID");
 	await I18n.done;

src/webpage/localuser.ts

@@ -722,6 +722,11 @@ class Localuser {
 	}
 	conectionChange = () => {};
 	async handleEvent(temp: wsjson) {
+		try {
+			window.checker?.checkEvent(temp);
+		} catch (e) {
+			console.error(e);
+		}
 		if (temp.d._trace) this.handleTrace(temp.d._trace);
 		if (getDeveloperSettings().gatewayLogging) console.debug(temp);
 		if (temp.s) this.lastSequence = temp.s;

src/webpage/typeChecker/basetype.ts

@@ -0,0 +1,41 @@
+import {ArrayChecker} from "./checkers/array";
+import {BoolChecker} from "./checkers/bool";
+import {Never} from "./checkers/never";
+import {NumberChecker} from "./checkers/number";
+import {ObjectChecker} from "./checkers/object";
+import {StringChecker} from "./checkers/string";
+
+export abstract class TypeChecker {
+	abstract check(obj: unknown): void;
+	static resolve(r: resolveable): TypeChecker {
+		if (r instanceof TypeChecker) return r;
+		if (typeof r === "string" || r instanceof RegExp) {
+			return new StringChecker(r);
+		} else if (r === String) {
+			return new StringChecker();
+		} else if (r === Boolean) {
+			return new BoolChecker();
+		} else if (r === Number) {
+			return new NumberChecker();
+		} else if (typeof r === "number") {
+			return new NumberChecker(r);
+		} else if (r instanceof Array) {
+			return new ArrayChecker(r);
+		} else if (r instanceof Object) {
+			return new ObjectChecker(r as {[key: string]: resolveable});
+		} else {
+			return new Never();
+		}
+	}
+}
+
+export type resolveable =
+	| typeof String
+	| string
+	| number
+	| typeof Number
+	| RegExp
+	| resolveable[]
+	| {[key: string]: resolveable}
+	| TypeChecker
+	| typeof Boolean;

src/webpage/typeChecker/checkers/any.ts

@@ -0,0 +1,10 @@
+import {TypeChecker} from "../basetype";
+
+export class Any extends TypeChecker {
+	constructor() {
+		super();
+	}
+	check() {
+		return;
+	}
+}

src/webpage/typeChecker/checkers/array.ts

@@ -0,0 +1,26 @@
+import {resolveable, TypeChecker} from "../basetype";
+
+export class ArrayChecker extends TypeChecker {
+	arr: TypeChecker | TypeChecker[];
+	constructor(arr: resolveable | resolveable[]) {
+		super();
+		if (arr instanceof Array) {
+			this.arr = arr.map((_) => TypeChecker.resolve(_));
+		} else {
+			this.arr = TypeChecker.resolve(arr);
+		}
+	}
+	check(obj: unknown) {
+		if (!(obj instanceof Array)) throw new Error(`${obj} is not of type array`);
+		if (this.arr instanceof Array) {
+			if (this.arr.length !== obj.length) throw new Error(`${obj} does not match array schema`);
+			for (let i = 0; i < obj.length; i++) {
+				this.arr[i].check(obj[i]);
+			}
+		} else {
+			for (const elm of obj) {
+				this.arr.check(elm);
+			}
+		}
+	}
+}

src/webpage/typeChecker/checkers/bool.ts

@@ -0,0 +1,10 @@
+import {TypeChecker} from "../basetype";
+
+export class BoolChecker extends TypeChecker {
+	constructor() {
+		super();
+	}
+	check(obj: unknown): void {
+		if (typeof obj !== "boolean") throw new Error(`${obj} is not a bool`);
+	}
+}

src/webpage/typeChecker/checkers/never.ts

@@ -0,0 +1,10 @@
+import {TypeChecker} from "../basetype";
+
+export class Never extends TypeChecker {
+	constructor() {
+		super();
+	}
+	check(): void {
+		throw new Error(`never`);
+	}
+}

src/webpage/typeChecker/checkers/null.ts

@@ -0,0 +1,10 @@
+import {TypeChecker} from "../basetype";
+
+export class NullChecker extends TypeChecker {
+	constructor() {
+		super();
+	}
+	check(obj: unknown): void {
+		if (obj !== null) throw new Error(`${obj} is not null`);
+	}
+}

src/webpage/typeChecker/checkers/nullish.ts

@@ -0,0 +1,13 @@
+import {resolveable, TypeChecker} from "../basetype";
+
+export class Nullish extends TypeChecker {
+	checker: TypeChecker;
+	constructor(check: resolveable) {
+		super();
+		this.checker = TypeChecker.resolve(check);
+	}
+	check(obj: unknown) {
+		if (obj === null) return;
+		this.checker.check(obj);
+	}
+}