utilium 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './misc.js';
+export * from './numbers.js';
+export * from './objects.js';
+export * from './random.js';
+export * from './types.js';

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './misc.js';
+export * from './numbers.js';
+export * from './objects.js';
+export * from './random.js';
+export * from './types.js';

package/dist/misc.d.ts

@@ -0,0 +1,3 @@
+export declare function wait(time: number): Promise<unknown>;
+export declare const greekLetterNames: string[];
+export declare function isHex(str: string): boolean;

package/dist/misc.js

@@ -0,0 +1,33 @@
+export function wait(time) {
+    return new Promise(resolve => setTimeout(resolve, time));
+}
+export const greekLetterNames = [
+    'Alpha',
+    'Beta',
+    'Gamma',
+    'Delta',
+    'Epsilon',
+    'Zeta',
+    'Eta',
+    'Theta',
+    'Iota',
+    'Kappa',
+    'Lambda',
+    'Mu',
+    'Nu',
+    'Xi',
+    'Omicron',
+    'Pi',
+    'Rho',
+    'Sigma',
+    'Tau',
+    'Upsilon',
+    'Phi',
+    'Chi',
+    'Psi',
+    'Omega',
+];
+const hexRegex = /^[0-9a-f-.]+$/;
+export function isHex(str) {
+    return hexRegex.test(str);
+}

package/dist/numbers.d.ts

@@ -0,0 +1,3 @@
+export declare function range(min: number, max: number): number[];
+export declare function toDegrees(radians: number): number;
+export declare function toRadians(degrees: number): number;

package/dist/numbers.js

@@ -0,0 +1,13 @@
+export function range(min, max) {
+    const a = [];
+    for (let i = min; i < max; i++) {
+        a.push(i);
+    }
+    return a;
+}
+export function toDegrees(radians) {
+    return (radians * 180) / Math.PI;
+}
+export function toRadians(degrees) {
+    return (degrees / 180) * Math.PI;
+}

package/dist/objects.d.ts

@@ -0,0 +1,81 @@
+/// <reference types="node" resolution-mode="require"/>
+export declare function filterObject<T extends object, K extends keyof T>(object: T, ...keys: K[]): Omit<T, K>;
+import type * as FS from 'fs';
+export declare function isJSON(str: string): boolean;
+export declare abstract class FileMap<V> implements Map<string, V> {
+    protected readonly path: string;
+    protected fs: typeof FS;
+    get [Symbol.toStringTag](): string;
+    constructor(path: string, fs?: typeof FS);
+    protected abstract readonly _map: Map<string, V>;
+    abstract clear(): void;
+    abstract delete(key: string): boolean;
+    abstract get(key: string): V;
+    abstract has(key: string): boolean;
+    abstract set(key: string, value: V): this;
+    get size(): number;
+    get [Symbol.iterator](): any;
+    get keys(): typeof this._map.keys;
+    get values(): typeof this._map.values;
+    get entries(): typeof this._map.entries;
+    get forEach(): typeof this._map.forEach;
+}
+export type JSONObject<Key extends string | number | symbol = string> = {
+    [K in Key]: JSONValue;
+};
+export type JSONValue<Key extends string | number | symbol = string> = string | number | boolean | JSONObject<Key> | Array<JSONValue>;
+export interface JSONFileMapOptions {
+    /**
+     * Should an invalid JSON file be overwritten
+     */
+    overwrite_invalid_json: boolean;
+    /**
+     *
+     */
+    fs: typeof FS;
+}
+/**
+ * A Map overlaying a JSON file
+ */
+export declare class JSONFileMap<T extends JSONValue = JSONValue> extends FileMap<T> {
+    readonly options: JSONFileMapOptions;
+    get [Symbol.toStringTag](): 'JSONFileMap';
+    constructor(path: string, options: JSONFileMapOptions);
+    get _map(): Map<string, T>;
+    _write(map: Map<string, T>): void;
+    clear(): void;
+    delete(key: string): boolean;
+    get<U extends T>(key: string): U;
+    has(key: string): boolean;
+    set(key: string, value: T): this;
+}
+export interface FolderMapOptions {
+    /**
+     * Suffix to append to keys to resolve file names
+     */
+    suffix: string;
+    fs?: typeof FS;
+}
+/**
+ * A Map overlaying a folder
+ */
+export declare class FolderMap extends FileMap<string> {
+    readonly options: Partial<FolderMapOptions>;
+    get [Symbol.toStringTag](): 'FolderMap';
+    constructor(path: string, options: Partial<FolderMapOptions>);
+    protected get _names(): string[];
+    protected _join(path: string): string;
+    protected get _map(): Map<string, string>;
+    clear(): void;
+    delete(key: string): boolean;
+    get(key: string): string;
+    has(key: string): boolean;
+    set(key: string, value: string): this;
+}
+export declare function resolveConstructors(object: object): string[];
+/**
+ * Gets a random int, r, with the probability P(r) = (base)**r
+ * For example, with a probability of 1/2: P(1) = 1/2, P(2) = 1/4, etc.
+ * @param probability the probability
+ */
+export declare function getRandomIntWithRecursiveProbability(probability?: number): number;

package/dist/objects.js

@@ -0,0 +1,178 @@
+export function filterObject(object, ...keys) {
+    const entries = Object.entries(object);
+    return Object.fromEntries(entries.filter(([key]) => keys.includes(key)));
+}
+let _fs;
+try {
+    _fs = await import('fs');
+}
+catch (e) {
+    _fs = null;
+}
+export function isJSON(str) {
+    try {
+        JSON.parse(str);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+export class FileMap {
+    get [Symbol.toStringTag]() {
+        return 'FileMap';
+    }
+    constructor(path, fs = _fs) {
+        this.path = path;
+        this.fs = fs;
+        if (!path) {
+            throw new ReferenceError('No path specified');
+        }
+        if (!fs) {
+            throw new ReferenceError('No filesystem API');
+        }
+    }
+    get size() {
+        return this._map.size;
+    }
+    get [Symbol.iterator]() {
+        return this._map[Symbol.iterator].bind(this._map);
+    }
+    get keys() {
+        return this._map.keys.bind(this._map);
+    }
+    get values() {
+        return this._map.values.bind(this._map);
+    }
+    get entries() {
+        return this._map.entries.bind(this._map);
+    }
+    get forEach() {
+        return this._map.forEach.bind(this._map);
+    }
+}
+/**
+ * A Map overlaying a JSON file
+ */
+export class JSONFileMap extends FileMap {
+    get [Symbol.toStringTag]() {
+        return 'JSONFileMap';
+    }
+    constructor(path, options) {
+        super(path, options.fs);
+        this.options = options;
+        if (!this.fs.existsSync(path)) {
+            this.fs.writeFileSync(path, '{}');
+        }
+    }
+    get _map() {
+        const content = this.fs.readFileSync(this.path, 'utf8');
+        if (!isJSON(content)) {
+            if (!this.options.overwrite_invalid_json) {
+                throw new SyntaxError('Invalid JSON file: ' + this.path);
+            }
+            console.warn('Invalid JSON file (overwriting): ' + this.path);
+            this.clear();
+            return new Map();
+        }
+        return new Map(Object.entries(JSON.parse(content)));
+    }
+    _write(map) {
+        if (!this.fs.existsSync(this.path)) {
+            this.fs.writeFileSync(this.path, '{}');
+        }
+        const content = JSON.stringify(Object.fromEntries(map));
+        this.fs.writeFileSync(this.path, content);
+    }
+    clear() {
+        this.fs.writeFileSync(this.path, '{}');
+    }
+    delete(key) {
+        const map = this._map;
+        const rt = map.delete(key);
+        this._write(map);
+        return rt;
+    }
+    get(key) {
+        return this._map.get(key);
+    }
+    has(key) {
+        return this._map.has(key);
+    }
+    set(key, value) {
+        const map = this._map;
+        map.set(key, value);
+        this._write(map);
+        return this;
+    }
+}
+/**
+ * A Map overlaying a folder
+ */
+export class FolderMap extends FileMap {
+    get [Symbol.toStringTag]() {
+        return 'FolderMap';
+    }
+    constructor(path, options) {
+        super(path, options.fs);
+        this.options = options;
+    }
+    get _names() {
+        return this.fs
+            .readdirSync(this.path)
+            .filter(p => p.endsWith(this.options.suffix))
+            .map(p => p.slice(0, -this.options.suffix.length));
+    }
+    _join(path) {
+        return `${this.path}/${path}${this.options.suffix}`;
+    }
+    get _map() {
+        const entries = [];
+        for (const name of this._names) {
+            const content = this.fs.readFileSync(this._join(name), 'utf8');
+            entries.push([name, content]);
+        }
+        return new Map(entries);
+    }
+    clear() {
+        for (const name of this._names) {
+            this.fs.unlinkSync(this._join(name));
+        }
+    }
+    delete(key) {
+        if (!this.has(key)) {
+            return false;
+        }
+        this.fs.unlinkSync(this._join(key));
+        return true;
+    }
+    get(key) {
+        if (this.has(key)) {
+            return this.fs.readFileSync(this._join(key), 'utf8');
+        }
+    }
+    has(key) {
+        return this._names.includes(key);
+    }
+    set(key, value) {
+        this.fs.writeFileSync(this._join(key), value);
+        return this;
+    }
+}
+export function resolveConstructors(object) {
+    const constructors = [];
+    let prototype = object;
+    while (prototype && !['Function', 'Object'].includes(prototype.constructor.name)) {
+        prototype = Object.getPrototypeOf(prototype);
+        constructors.push(prototype.constructor.name);
+    }
+    return constructors;
+}
+/**
+ * Gets a random int, r, with the probability P(r) = (base)**r
+ * For example, with a probability of 1/2: P(1) = 1/2, P(2) = 1/4, etc.
+ * @param probability the probability
+ */
+export function getRandomIntWithRecursiveProbability(probability = 0.5) {
+    return -Math.floor(Math.log(Math.random()) / Math.log(1 / probability));
+}

package/dist/random.d.ts

@@ -0,0 +1,5 @@
+export declare function randomFloat(min?: number, max?: number): number;
+export declare function randomHex(length?: number): string;
+export declare function randomBoolean(): boolean;
+export declare function randomBinaryString(length?: number): string;
+export declare function randomInt(min?: number, max?: number): number;

package/dist/random.js

@@ -0,0 +1,23 @@
+export function randomFloat(min = 0, max = 1) {
+    return Math.random() * (max - min) + min;
+}
+export function randomHex(length = 1) {
+    let s = '';
+    for (let i = 0; i < length; i++) {
+        s += Math.floor(Math.random() * 16).toString(16);
+    }
+    return s;
+}
+export function randomBoolean() {
+    return !!Math.round(Math.random());
+}
+export function randomBinaryString(length = 1) {
+    let b = '';
+    for (let i = 0; i < length; i++) {
+        b += Math.round(Math.random());
+    }
+    return b;
+}
+export function randomInt(min = 0, max = 1) {
+    return Math.round(Math.random() * (max - min) + min);
+}

package/dist/types.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Expands the type T (for intellisense and debugging)
+ * @see https://stackoverflow.com/a/69288824/17637456
+ */
+export type Expand<T> = T extends (...args: infer A) => infer R ? (...args: Expand<A>) => Expand<R> : T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+/**
+ * Recursivly expands the type T (for intellisense and debugging)
+ * @see https://stackoverflow.com/a/69288824/17637456
+ */
+export type ExpandRecursively<T> = T extends (...args: infer A) => infer R ? (...args: ExpandRecursively<A>) => ExpandRecursively<R> : T extends object ? T extends infer O ? {
+    [K in keyof O]: ExpandRecursively<O[K]>;
+} : never : T;
+/**
+ * Extracts an object with properties assignable to P from an object T
+ * @see https://stackoverflow.com/a/71532723/17637456
+ */
+export type ExtractProperties<T, P> = {
+    [K in keyof T as T[K] extends infer Prop ? (Prop extends P ? K : never) : never]: T[K];
+};
+/**
+ * Extract the keys of T which are required
+ * @see https://stackoverflow.com/a/55247867/17637456
+ */
+export type RequiredKeys<T> = {
+    [K in keyof T]-?: {} extends {
+        [P in K]: T[K];
+    } ? never : K;
+}[keyof T];
+/**
+ * @see https://dev.to/tmhao2005/ts-useful-advanced-types-3k5e
+ */
+export type RequiredProperties<T extends object, K extends keyof T = keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+/**
+ * @see https://dev.to/tmhao2005/ts-useful-advanced-types-3k5e
+ */
+export type DeepRequired<T> = {
+    [K in keyof T]: Required<DeepRequired<T[K]>>;
+};
+/**
+ * @see https://dev.to/tmhao2005/ts-useful-advanced-types-3k5e
+ */
+export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<T>;
+/**
+ * @see https://dev.to/tmhao2005/ts-useful-advanced-types-3k5e
+ */
+export type NestedKeys<T extends object> = {
+    [P in keyof T & (string | number)]: T[P] extends Date ? `${P}` : T[P] extends Record<string, unknown> ? `${P}` | `${P}.${NestedKeys<T[P]>}` : `${P}`;
+}[keyof T & (string | number)];
+/**
+ * @see https://dev.to/tmhao2005/ts-useful-advanced-types-3k5e
+ */
+export type PartialRecursive<T> = {
+    [P in keyof T]?: T[P] extends (infer U)[] ? PartialRecursive<U>[] : T[P] extends object | undefined ? PartialRecursive<T[P]> : T[P];
+};
+/**
+ * Get the keys of a union of objects
+ * @see https://stackoverflow.com/a/65805753/17637456
+ */
+export type UnionKeys<T> = T extends T ? keyof T : never;
+type StrictUnionHelper<T, TAll> = T extends unknown ? T & Partial<Record<Exclude<UnionKeys<TAll>, keyof T>, never>> : never;
+/**
+ * @see https://stackoverflow.com/a/65805753/17637456
+ */
+export type StrictUnion<T> = Expand<StrictUnionHelper<T, T>>;
+export {};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,37 @@
+{
+	"name": "utilium",
+	"version": "0.0.1",
+	"description": "Utilies",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"type": "module",
+	"scripts": {
+		"format:check": "prettier --check .",
+		"format": "prettier --write .",
+		"lint": "eslint src && tsc --noEmit",
+		"build": "tsc -p tsconfig.json",
+		"build:docs": "typedoc src/index.ts --out docs",
+		"prepublishOnly": "npm run build"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/dr-vortex/utilium.git"
+	},
+	"author": "James P. <jp@drvortex.dev> (https://drvortex.dev)",
+	"license": "MIT",
+	"bugs": {
+		"url": "https://github.com/dr-vortex/utilium/issues"
+	},
+	"homepage": "https://github.com/dr-vortex/utilium#readme",
+	"devDependencies": {
+		"@typescript-eslint/eslint-plugin": "^6.2.0",
+		"@typescript-eslint/parser": "^6.2.0",
+		"eslint": "^8.45.0",
+		"prettier": "^3.2.5",
+		"typedoc": "^0.24.8",
+		"typescript": "^5.1.6"
+	},
+	"dependencies": {
+		"@types/node": "^20.12.7"
+	}
+}

package/readme.md

@@ -0,0 +1,3 @@
+# Utilium
+
+A bunch of utilies for Typescript that I have found to be very useful

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './misc.js';
+export * from './numbers.js';
+export * from './objects.js';
+export * from './random.js';
+export * from './types.js';

package/src/misc.ts

@@ -0,0 +1,36 @@
+export function wait(time: number) {
+	return new Promise(resolve => setTimeout(resolve, time));
+}
+
+export const greekLetterNames = [
+	'Alpha',
+	'Beta',
+	'Gamma',
+	'Delta',
+	'Epsilon',
+	'Zeta',
+	'Eta',
+	'Theta',
+	'Iota',
+	'Kappa',
+	'Lambda',
+	'Mu',
+	'Nu',
+	'Xi',
+	'Omicron',
+	'Pi',
+	'Rho',
+	'Sigma',
+	'Tau',
+	'Upsilon',
+	'Phi',
+	'Chi',
+	'Psi',
+	'Omega',
+];
+
+const hexRegex = /^[0-9a-f-.]+$/;
+
+export function isHex(str: string) {
+	return hexRegex.test(str);
+}

package/src/numbers.ts

@@ -0,0 +1,15 @@
+export function range(min: number, max: number): number[] {
+	const a = [];
+	for (let i = min; i < max; i++) {
+		a.push(i);
+	}
+	return a;
+}
+
+export function toDegrees(radians: number): number {
+	return (radians * 180) / Math.PI;
+}
+
+export function toRadians(degrees: number): number {
+	return (degrees / 180) * Math.PI;
+}

package/src/objects.ts

@@ -0,0 +1,253 @@
+export function filterObject<T extends object, K extends keyof T>(object: T, ...keys: K[]): Omit<T, K> {
+	const entries = <[K, T[K]][]>Object.entries(object);
+	return <Omit<T, K>>(<unknown>Object.fromEntries(entries.filter(([key]) => keys.includes(key))));
+}
+
+import type * as FS from 'fs';
+
+let _fs: typeof FS;
+try {
+	_fs = await import('fs');
+} catch (e) {
+	_fs = null;
+}
+
+export function isJSON(str: string) {
+	try {
+		JSON.parse(str);
+		return true;
+	} catch (e) {
+		return false;
+	}
+}
+
+export abstract class FileMap<V> implements Map<string, V> {
+	public get [Symbol.toStringTag](): string {
+		return 'FileMap';
+	}
+
+	public constructor(
+		protected readonly path: string,
+		protected fs: typeof FS = _fs
+	) {
+		if (!path) {
+			throw new ReferenceError('No path specified');
+		}
+
+		if (!fs) {
+			throw new ReferenceError('No filesystem API');
+		}
+	}
+
+	protected abstract readonly _map: Map<string, V>;
+
+	public abstract clear(): void;
+
+	public abstract delete(key: string): boolean;
+
+	public abstract get(key: string): V;
+
+	public abstract has(key: string): boolean;
+
+	public abstract set(key: string, value: V): this;
+
+	public get size() {
+		return this._map.size;
+	}
+
+	public get [Symbol.iterator]() {
+		return this._map[Symbol.iterator].bind(this._map);
+	}
+
+	public get keys(): typeof this._map.keys {
+		return this._map.keys.bind(this._map);
+	}
+
+	public get values(): typeof this._map.values {
+		return this._map.values.bind(this._map);
+	}
+
+	public get entries(): typeof this._map.entries {
+		return this._map.entries.bind(this._map);
+	}
+
+	public get forEach(): typeof this._map.forEach {
+		return this._map.forEach.bind(this._map);
+	}
+}
+
+export type JSONObject<Key extends string | number | symbol = string> = { [K in Key]: JSONValue };
+
+export type JSONValue<Key extends string | number | symbol = string> = string | number | boolean | JSONObject<Key> | Array<JSONValue>;
+
+export interface JSONFileMapOptions {
+	/**
+	 * Should an invalid JSON file be overwritten
+	 */
+	overwrite_invalid_json: boolean;
+
+	/**
+	 *
+	 */
+	fs: typeof FS;
+}
+
+/**
+ * A Map overlaying a JSON file
+ */
+export class JSONFileMap<T extends JSONValue = JSONValue> extends FileMap<T> {
+	public get [Symbol.toStringTag](): 'JSONFileMap' {
+		return 'JSONFileMap';
+	}
+
+	public constructor(
+		path: string,
+		public readonly options: JSONFileMapOptions
+	) {
+		super(path, options.fs);
+		if (!this.fs.existsSync(path)) {
+			this.fs.writeFileSync(path, '{}');
+		}
+	}
+
+	public get _map(): Map<string, T> {
+		const content = this.fs.readFileSync(this.path, 'utf8');
+		if (!isJSON(content)) {
+			if (!this.options.overwrite_invalid_json) {
+				throw new SyntaxError('Invalid JSON file: ' + this.path);
+			}
+			console.warn('Invalid JSON file (overwriting): ' + this.path);
+			this.clear();
+			return new Map();
+		}
+		return new Map(Object.entries(JSON.parse(content)));
+	}
+
+	public _write(map: Map<string, T>) {
+		if (!this.fs.existsSync(this.path)) {
+			this.fs.writeFileSync(this.path, '{}');
+		}
+		const content = JSON.stringify(Object.fromEntries(map));
+		this.fs.writeFileSync(this.path, content);
+	}
+
+	public clear() {
+		this.fs.writeFileSync(this.path, '{}');
+	}
+
+	public delete(key: string): boolean {
+		const map = this._map;
+		const rt = map.delete(key);
+		this._write(map);
+		return rt;
+	}
+
+	public get<U extends T>(key: string): U {
+		return this._map.get(key) as U;
+	}
+
+	public has(key: string): boolean {
+		return this._map.has(key);
+	}
+
+	public set(key: string, value: T): this {
+		const map = this._map;
+		map.set(key, value);
+		this._write(map);
+		return this;
+	}
+}
+
+export interface FolderMapOptions {
+	/**
+	 * Suffix to append to keys to resolve file names
+	 */
+	suffix: string;
+
+	fs?: typeof FS;
+}
+
+/**
+ * A Map overlaying a folder
+ */
+export class FolderMap extends FileMap<string> {
+	public get [Symbol.toStringTag](): 'FolderMap' {
+		return 'FolderMap';
+	}
+
+	public constructor(
+		path: string,
+		public readonly options: Partial<FolderMapOptions>
+	) {
+		super(path, options.fs);
+	}
+
+	protected get _names(): string[] {
+		return this.fs
+			.readdirSync(this.path)
+			.filter(p => p.endsWith(this.options.suffix))
+			.map(p => p.slice(0, -this.options.suffix.length));
+	}
+
+	protected _join(path: string): string {
+		return `${this.path}/${path}${this.options.suffix}`;
+	}
+
+	protected get _map(): Map<string, string> {
+		const entries = [];
+		for (const name of this._names) {
+			const content = this.fs.readFileSync(this._join(name), 'utf8');
+			entries.push([name, content]);
+		}
+		return new Map(entries);
+	}
+
+	public clear(): void {
+		for (const name of this._names) {
+			this.fs.unlinkSync(this._join(name));
+		}
+	}
+
+	public delete(key: string): boolean {
+		if (!this.has(key)) {
+			return false;
+		}
+
+		this.fs.unlinkSync(this._join(key));
+		return true;
+	}
+
+	public get(key: string): string {
+		if (this.has(key)) {
+			return this.fs.readFileSync(this._join(key), 'utf8');
+		}
+	}
+
+	public has(key: string): boolean {
+		return this._names.includes(key);
+	}
+
+	public set(key: string, value: string): this {
+		this.fs.writeFileSync(this._join(key), value);
+		return this;
+	}
+}
+
+export function resolveConstructors(object: object): string[] {
+	const constructors = [];
+	let prototype = object;
+	while (prototype && !['Function', 'Object'].includes(prototype.constructor.name)) {
+		prototype = Object.getPrototypeOf(prototype);
+		constructors.push(prototype.constructor.name);
+	}
+	return constructors;
+}
+
+/**
+ * Gets a random int, r, with the probability P(r) = (base)**r
+ * For example, with a probability of 1/2: P(1) = 1/2, P(2) = 1/4, etc.
+ * @param probability the probability
+ */
+export function getRandomIntWithRecursiveProbability(probability = 0.5): number {
+	return -Math.floor(Math.log(Math.random()) / Math.log(1 / probability));
+}

package/src/random.ts

@@ -0,0 +1,27 @@
+export function randomFloat(min = 0, max = 1): number {
+	return Math.random() * (max - min) + min;
+}
+
+export function randomHex(length = 1): string {
+	let s = '';
+	for (let i = 0; i < length; i++) {
+		s += Math.floor(Math.random() * 16).toString(16);
+	}
+	return s;
+}
+
+export function randomBoolean(): boolean {
+	return !!Math.round(Math.random());
+}
+
+export function randomBinaryString(length = 1): string {
+	let b = '';
+	for (let i = 0; i < length; i++) {
+		b += Math.round(Math.random());
+	}
+	return b;
+}
+
+export function randomInt(min = 0, max = 1): number {
+	return Math.round(Math.random() * (max - min) + min);
+}

package/src/types.ts

@@ -0,0 +1,76 @@
+/**
+ * Expands the type T (for intellisense and debugging)
+ * @see https://stackoverflow.com/a/69288824/17637456
+ */
+export type Expand<T> = T extends (...args: infer A) => infer R ? (...args: Expand<A>) => Expand<R> : T extends infer O ? { [K in keyof O]: O[K] } : never;
+
+/**
+ * Recursivly expands the type T (for intellisense and debugging)
+ * @see https://stackoverflow.com/a/69288824/17637456
+ */
+export type ExpandRecursively<T> = T extends (...args: infer A) => infer R
+	? (...args: ExpandRecursively<A>) => ExpandRecursively<R>
+	: T extends object
+		? T extends infer O
+			? { [K in keyof O]: ExpandRecursively<O[K]> }
+			: never
+		: T;
+
+/**
+ * Extracts an object with properties assignable to P from an object T
+ * @see https://stackoverflow.com/a/71532723/17637456
+ */
+export type ExtractProperties<T, P> = {
+	[K in keyof T as T[K] extends infer Prop ? (Prop extends P ? K : never) : never]: T[K];
+};
+
+/**
+ * Extract the keys of T which are required
+ * @see https://stackoverflow.com/a/55247867/17637456
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type RequiredKeys<T> = { [K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K }[keyof T];
+
+/**
+ * @see https://dev.to/tmhao2005/ts-useful-advanced-types-3k5e
+ */
+export type RequiredProperties<T extends object, K extends keyof T = keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+
+/**
+ * @see https://dev.to/tmhao2005/ts-useful-advanced-types-3k5e
+ */
+export type DeepRequired<T> = {
+	[K in keyof T]: Required<DeepRequired<T[K]>>;
+};
+
+/**
+ * @see https://dev.to/tmhao2005/ts-useful-advanced-types-3k5e
+ */
+export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<T>;
+
+/**
+ * @see https://dev.to/tmhao2005/ts-useful-advanced-types-3k5e
+ */
+export type NestedKeys<T extends object> = {
+	[P in keyof T & (string | number)]: T[P] extends Date ? `${P}` : T[P] extends Record<string, unknown> ? `${P}` | `${P}.${NestedKeys<T[P]>}` : `${P}`;
+}[keyof T & (string | number)];
+
+/**
+ * @see https://dev.to/tmhao2005/ts-useful-advanced-types-3k5e
+ */
+export type PartialRecursive<T> = {
+	[P in keyof T]?: T[P] extends (infer U)[] ? PartialRecursive<U>[] : T[P] extends object | undefined ? PartialRecursive<T[P]> : T[P];
+};
+
+/**
+ * Get the keys of a union of objects
+ * @see https://stackoverflow.com/a/65805753/17637456
+ */
+export type UnionKeys<T> = T extends T ? keyof T : never;
+
+type StrictUnionHelper<T, TAll> = T extends unknown ? T & Partial<Record<Exclude<UnionKeys<TAll>, keyof T>, never>> : never;
+
+/**
+ * @see https://stackoverflow.com/a/65805753/17637456
+ */
+export type StrictUnion<T> = Expand<StrictUnionHelper<T, T>>;