utilium 0.4.1 → 0.4.3

package/dist/list.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" resolution-mode="require"/>
+import { EventEmitter } from 'eventemitter3';
+export declare class List<T> extends EventEmitter<'update'> implements Set<T>, RelativeIndexable<T> {
+    readonly [Symbol.toStringTag] = "List";
+    protected data: Set<T>;
+    array(): T[];
+    json(): string;
+    toString(): string;
+    set(index: number, value: T): void;
+    deleteAt(index: number): void;
+    at(index: number): T;
+    pop(): T | undefined;
+    push(...items: T[]): number;
+    join(separator?: string): string;
+    splice(start: number, deleteCount: number, ...items: T[]): T[];
+    add(value: T): this;
+    clear(): void;
+    delete(value: T): boolean;
+    forEach(callbackfn: (value: T, value2: T, list: List<T>) => void, thisArg?: any): void;
+    has(value: T): boolean;
+    get size(): number;
+    entries(): IterableIterator<[T, T]>;
+    keys(): IterableIterator<T>;
+    values(): IterableIterator<T>;
+    [Symbol.iterator](): IterableIterator<T>;
+}

package/dist/list.js

@@ -0,0 +1,99 @@
+import { EventEmitter } from 'eventemitter3';
+export class List extends EventEmitter {
+    [Symbol.toStringTag] = 'List';
+    data = new Set();
+    array() {
+        return [...this.data];
+    }
+    json() {
+        return JSON.stringify([...this.data]);
+    }
+    toString() {
+        return this.join(',');
+    }
+    set(index, value) {
+        if (Math.abs(index) > this.data.size) {
+            throw new ReferenceError('Can not set an element outside the bounds of the list');
+        }
+        const data = [...this.data];
+        data.splice(index, 1, value);
+        this.data = new Set(data);
+        this.emit('update');
+    }
+    deleteAt(index) {
+        if (Math.abs(index) > this.data.size) {
+            throw new ReferenceError('Can not delete an element outside the bounds of the list');
+        }
+        this.delete([...this.data].at(index));
+    }
+    // Array methods
+    at(index) {
+        if (Math.abs(index) > this.data.size) {
+            throw new ReferenceError('Can not access an element outside the bounds of the list');
+        }
+        return [...this.data].at(index);
+    }
+    pop() {
+        const item = [...this.data].pop();
+        if (item !== undefined) {
+            this.delete(item);
+        }
+        return item;
+    }
+    push(...items) {
+        for (const item of items) {
+            this.add(item);
+        }
+        return this.data.size;
+    }
+    join(separator) {
+        return [...this.data].join(separator);
+    }
+    splice(start, deleteCount, ...items) {
+        if (Math.abs(start) > this.data.size) {
+            throw new ReferenceError('Can not splice elements outside the bounds of the list');
+        }
+        const data = [...this.data];
+        const deleted = data.splice(start, deleteCount, ...items);
+        this.data = new Set(data);
+        this.emit('update');
+        return deleted;
+    }
+    // Set methods
+    add(value) {
+        this.data.add(value);
+        this.emit('update');
+        return this;
+    }
+    clear() {
+        this.data.clear();
+        this.emit('update');
+    }
+    delete(value) {
+        const success = this.data.delete(value);
+        this.emit('update');
+        return success;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    forEach(callbackfn, thisArg) {
+        this.data.forEach((v1, v2) => callbackfn.call(thisArg, v1, v2, this));
+    }
+    has(value) {
+        return this.data.has(value);
+    }
+    get size() {
+        return this.data.size;
+    }
+    entries() {
+        return this.data.entries();
+    }
+    keys() {
+        return this.data.keys();
+    }
+    values() {
+        return this.data.values();
+    }
+    [Symbol.iterator]() {
+        return this.data[Symbol.iterator]();
+    }
+}

package/dist/objects.d.ts

@@ -42,7 +42,7 @@ export interface JSONFileMapOptions {
      */
     overwrite_invalid_json: boolean;
     /**
-     *
+     * FS module
      */
     fs: typeof FS;
 }

package/dist/types.d.ts

@@ -143,7 +143,7 @@ export type FlattenArray<A extends unknown[], D = null> = A extends (infer U)[]
 /**
  * Whether T is a tuple
  */
-export type IsTuple<T> = T extends [] ? false : T extends [infer Head, ...infer Rest] ? true : false;
+export type IsTuple<T> = T extends [] ? false : T extends [infer _Head, ...infer _Rest] ? true : false;
 /**
  * Flattens a tuple
  */
@@ -181,4 +181,11 @@ export type LastOfUnion<T> = UnionToIntersection<T extends any ? () => T : never
  * @see https://stackoverflow.com/a/55128956/17637456
  */
 export type UnionToTuple<T, L = LastOfUnion<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple<Exclude<T, L>>, L>;
+/**
+ * Makes properties with keys assignable to K in T required
+ * @see https://stackoverflow.com/a/69328045/17637456
+ */
+export type WithRequired<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "utilium",
-	"version": "0.4.1",
+	"version": "0.4.3",
 	"description": "Typescript utilies",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -31,5 +31,8 @@
 		"prettier": "^3.2.5",
 		"typedoc": "^0.24.8",
 		"typescript": "^5.1.6"
+	},
+	"dependencies": {
+		"eventemitter3": "^5.0.1"
 	}
 }

package/src/list.ts

@@ -0,0 +1,127 @@
+import { EventEmitter } from 'eventemitter3';
+
+export class List<T> extends EventEmitter<'update'> implements Set<T>, RelativeIndexable<T> {
+	public readonly [Symbol.toStringTag] = 'List';
+
+	protected data = new Set<T>();
+
+	public array(): T[] {
+		return [...this.data];
+	}
+
+	public json() {
+		return JSON.stringify([...this.data]);
+	}
+
+	public toString() {
+		return this.join(',');
+	}
+
+	public set(index: number, value: T): void {
+		if (Math.abs(index) > this.data.size) {
+			throw new ReferenceError('Can not set an element outside the bounds of the list');
+		}
+
+		const data = [...this.data];
+		data.splice(index, 1, value);
+		this.data = new Set<T>(data);
+		this.emit('update');
+	}
+
+	public deleteAt(index: number): void {
+		if (Math.abs(index) > this.data.size) {
+			throw new ReferenceError('Can not delete an element outside the bounds of the list');
+		}
+
+		this.delete([...this.data].at(index)!);
+	}
+
+	// Array methods
+
+	public at(index: number): T {
+		if (Math.abs(index) > this.data.size) {
+			throw new ReferenceError('Can not access an element outside the bounds of the list');
+		}
+
+		return [...this.data].at(index)!;
+	}
+
+	public pop(): T | undefined {
+		const item = [...this.data].pop();
+		if (item !== undefined) {
+			this.delete(item);
+		}
+		return item;
+	}
+
+	public push(...items: T[]): number {
+		for (const item of items) {
+			this.add(item);
+		}
+		return this.data.size;
+	}
+
+	public join(separator?: string): string {
+		return [...this.data].join(separator);
+	}
+
+	public splice(start: number, deleteCount: number, ...items: T[]): T[] {
+		if (Math.abs(start) > this.data.size) {
+			throw new ReferenceError('Can not splice elements outside the bounds of the list');
+		}
+
+		const data = [...this.data];
+		const deleted = data.splice(start, deleteCount, ...items);
+		this.data = new Set<T>(data);
+		this.emit('update');
+		return deleted;
+	}
+
+	// Set methods
+
+	public add(value: T): this {
+		this.data.add(value);
+		this.emit('update');
+		return this;
+	}
+
+	public clear(): void {
+		this.data.clear();
+		this.emit('update');
+	}
+
+	public delete(value: T): boolean {
+		const success = this.data.delete(value);
+		this.emit('update');
+		return success;
+	}
+
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	public forEach(callbackfn: (value: T, value2: T, list: List<T>) => void, thisArg?: any): void {
+		this.data.forEach((v1, v2) => callbackfn.call(thisArg, v1, v2, this));
+	}
+
+	public has(value: T): boolean {
+		return this.data.has(value);
+	}
+
+	public get size(): number {
+		return this.data.size;
+	}
+
+	public entries(): IterableIterator<[T, T]> {
+		return this.data.entries();
+	}
+
+	public keys(): IterableIterator<T> {
+		return this.data.keys();
+	}
+
+	public values(): IterableIterator<T> {
+		return this.data.values();
+	}
+
+	public [Symbol.iterator](): IterableIterator<T> {
+		return this.data[Symbol.iterator]();
+	}
+}

package/src/objects.ts

@@ -113,7 +113,7 @@ export interface JSONFileMapOptions {
 	overwrite_invalid_json: boolean;
 
 	/**
-	 *
+	 * FS module
 	 */
 	fs: typeof FS;
 }

package/src/types.ts

@@ -172,7 +172,8 @@ export type FlattenArray<A extends unknown[], D = null> = A extends (infer U)[]
 /**
  * Whether T is a tuple
  */
-export type IsTuple<T> = T extends [] ? false : T extends [infer Head, ...infer Rest] ? true : false;
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export type IsTuple<T> = T extends [] ? false : T extends [infer _Head, ...infer _Rest] ? true : false;
 
 /**
  * Flattens a tuple
@@ -220,3 +221,9 @@ export type LastOfUnion<T> = UnionToIntersection<T extends any ? () => T : never
  * @see https://stackoverflow.com/a/55128956/17637456
  */
 export type UnionToTuple<T, L = LastOfUnion<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple<Exclude<T, L>>, L>;
+
+/**
+ * Makes properties with keys assignable to K in T required
+ * @see https://stackoverflow.com/a/69328045/17637456
+ */
+export type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] };