sail said to not actually use the code of this commit

Author: mProjectsCode

src/utils/prop/PropAccess.ts

@@ -0,0 +1,90 @@
+export enum PROP_ACCESS_TYPE {
+	OBJECT = 'object',
+	ARRAY = 'array',
+}
+
+export class PropAccessResult {
+	parent: unknown;
+	access: PropAccess;
+	child: unknown;
+
+	constructor(parent: unknown, access: PropAccess, child: unknown) {
+		this.parent = parent;
+		this.access = access;
+		this.child = child;
+	}
+}
+
+function accessGet(obj: unknown, prop: string): unknown {
+	// @ts-ignore
+	return obj[prop];
+}
+
+function accessSet(obj: unknown, prop: string, value: unknown): void {
+	// @ts-ignore
+	obj[prop] = value;
+}
+
+export class PropAccess {
+	type: PROP_ACCESS_TYPE;
+	prop: string;
+	index: number;
+
+	constructor(type: PROP_ACCESS_TYPE, prop: string) {
+		this.type = type;
+		this.prop = type === PROP_ACCESS_TYPE.OBJECT ? prop : '';
+		this.index = type === PROP_ACCESS_TYPE.ARRAY ? Number(prop) : 0;
+
+		if (Number.isNaN(this.index)) {
+			throw new Error('can not access array with non number index');
+		}
+	}
+
+	get(obj: unknown): PropAccessResult {
+		if (this.type === PROP_ACCESS_TYPE.OBJECT) {
+			if (typeof obj !== 'object' || obj == null) {
+				throw new Error('can not access property of non-object');
+			}
+
+			return new PropAccessResult(obj, this, accessGet(obj, this.prop));
+		} else {
+			if (typeof obj !== 'object' || obj == null || !Array.isArray(obj)) {
+				throw new Error('can not access property of non-array');
+			}
+
+			return new PropAccessResult(obj, this, obj[this.index]);
+		}
+	}
+
+	set(obj: unknown, value: unknown): void {
+		if (this.type === PROP_ACCESS_TYPE.OBJECT) {
+			if (typeof obj !== 'object' || obj == null) {
+				throw new Error('can not access property of non-object');
+			}
+
+			accessSet(obj, this.prop, value);
+		} else {
+			if (typeof obj !== 'object' || obj == null || !Array.isArray(obj)) {
+				throw new Error('can not access property of non-array');
+			}
+
+			obj[this.index] = value;
+		}
+	}
+
+	create(obj: unknown): void {
+		if (this.type === PROP_ACCESS_TYPE.OBJECT) {
+			if (typeof obj !== 'object' || obj == null) {
+				throw new Error('can not access property of non-object');
+			}
+
+			accessSet(obj, this.prop, undefined);
+		} else {
+			if (typeof obj !== 'object' || obj == null || !Array.isArray(obj)) {
+				throw new Error('can not access property of non-array');
+			}
+
+			obj[this.index] = undefined;
+		}
+	}
+}

src/utils/prop/PropPath.ts

@@ -0,0 +1,85 @@
+import { PropAccess, PropAccessResult } from './PropAccess';
+
+export class PropPath {
+	path: PropAccess[];
+
+	constructor(path: PropAccess[]) {
+		this.path = path;
+	}
+
+	get(obj: unknown): PropAccessResult {
+		if (this.path.length === 0) {
+			throw new Error('can not use empty path to access object');
+		}
+
+		let result = this.path[0].get(obj);
+
+		for (let access of this.path.slice(1)) {
+			result = access.get(result.child);
+		}
+
+		return result;
+	}
+
+	tryGet(obj: unknown): PropAccessResult | undefined {
+		try {
+			return this.get(obj);
+		} catch (e) {
+			console.error(e);
+			return undefined;
+		}
+	}
+
+	set(obj: unknown, value: unknown): void {
+		if (this.path.length === 0) {
+			throw new Error('can not use empty path to access object');
+		}
+
+		let result = this.path[0].get(obj);
+
+		for (let access of this.path.slice(1)) {
+			result = access.get(result.child);
+		}
+
+		result.access.set(result.parent, value);
+	}
+
+	setAndCreate(obj: unknown, value: unknown): void {
+		if (this.path.length === 0) {
+			throw new Error('can not use empty path to access object');
+		}
+
+		let result = this.path[0].get(obj);
+
+		if (result.child === undefined) {
+			result.access.set(result.parent, this.getNextPathElementValue(0, value));
+			result = result.access.get(result.parent);
+		}
+
+		for (let i = 1; i < this.path.length; i++) {
+			let access = this.path[i];
+			result = access.get(result.child);
+
+			if (result.child === undefined) {
+				result.access.set(result.parent, this.getNextPathElementValue(i, value));
+				result = result.access.get(result.parent);
+			}
+		}
+
+		result.access.set(result.parent, value);
+	}
+
+	getNextPathElement(index: number): PropAccess | undefined {
+		return this.path[index + 1];
+	}
+
+	getNextPathElementValue(index: number, value: unknown): unknown {
+		const nextPathElement = this.getNextPathElement(index);
+
+		if (nextPathElement === undefined) {
+			return value;
+		}
+
+		return nextPathElement.type === 'object' ? {} : [];
+	}
+}

src/utils/prop/PropUtils.ts

@@ -0,0 +1,20 @@
+import { PropPath } from './PropPath';
+import { PropAccessResult } from './PropAccess';
+
+export class PropUtils {
+	static get(obj: unknown, path: PropPath): unknown {
+		return path.get(obj).child;
+	}
+
+	static fullGet(obj: unknown, path: PropPath): PropAccessResult {
+		return path.get(obj);
+	}
+
+	static set(obj: unknown, path: PropPath, value: unknown): void {
+		return path.set(obj, value);
+	}
+
+	static setAndCreate(obj: unknown, path: PropPath, value: unknown): void {
+		return path.setAndCreate(obj, value);
+	}
+}