utilium 1.0.3 → 1.1.0

package/dist/internal/struct.d.ts

@@ -1,5 +1,11 @@
 import type { ClassLike } from '../types.js';
 import type * as primitive from './primitives.js';
+declare global {
+    interface SymbolConstructor {
+        readonly struct_init: unique symbol;
+        readonly struct_metadata: unique symbol;
+    }
+}
 export interface MemberInit {
     name: string;
     type: string | ClassLike;

package/dist/list.d.ts

@@ -7,8 +7,10 @@ export declare class List<T> extends EventEmitter<'update'> implements RelativeI
     toArray(): T[];
     toJSON(): string;
     toString(): string;
+    protected _set(index: number, value: T, _delete?: boolean): void;
     set(index: number, value: T): void;
     deleteAt(index: number): void;
+    insert(value: T, index?: number): void;
     at(index: number): T;
     pop(): T | undefined;
     push(...items: T[]): number;
@@ -19,8 +21,8 @@ export declare class List<T> extends EventEmitter<'update'> implements RelativeI
     delete(value: T): boolean;
     has(value: T): boolean;
     get size(): number;
-    entries(): IterableIterator<[T, T]>;
-    keys(): IterableIterator<T>;
+    entries(): IterableIterator<[number, T]>;
+    keys(): IterableIterator<number>;
     values(): IterableIterator<T>;
     [Symbol.iterator](): IterableIterator<T>;
 }

package/dist/list.js

@@ -20,21 +20,27 @@ export class List extends EventEmitter {
     toString() {
         return this.join(',');
     }
-    set(index, value) {
+    _set(index, value, _delete = false) {
         if (Math.abs(index) > this.data.size) {
             throw new ReferenceError('Can not set an element outside the bounds of the list');
         }
         const data = Array.from(this.data);
-        data.splice(index, 1, value);
+        data.splice(index, +_delete, value);
         this.data = new Set(data);
         this.emit('update');
     }
+    set(index, value) {
+        this._set(index, value, true);
+    }
     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(Array.from(this.data).at(index));
     }
+    insert(value, index = this.data.size) {
+        this._set(index, value, false);
+    }
     // Array methods
     at(index) {
         if (Math.abs(index) > this.data.size) {
@@ -89,11 +95,12 @@ export class List extends EventEmitter {
     get size() {
         return this.data.size;
     }
+    // Iteration
     entries() {
-        return this.data.entries();
+        return this.toArray().entries();
     }
     keys() {
-        return this.data.keys();
+        return this.toArray().keys();
     }
     values() {
         return this.data.values();

package/package.json

@@ -1,7 +1,11 @@
 {
 	"name": "utilium",
-	"version": "1.0.3",
+	"version": "1.1.0",
 	"description": "Typescript utilities",
+	"funding": {
+		"type": "individual",
+		"url": "https://github.com/sponsors/james-pre"
+	},
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"type": "module",

package/src/internal/struct.ts

@@ -1,6 +1,13 @@
 import type { ClassLike } from '../types.js';
 import type * as primitive from './primitives.js';
 
+declare global {
+	interface SymbolConstructor {
+		readonly struct_init: unique symbol;
+		readonly struct_metadata: unique symbol;
+	}
+}
+
 // @ts-expect-error 2322
 Symbol.struct_init ||= Symbol('struct_init');
 

package/src/list.ts

@@ -28,17 +28,21 @@ export class List<T> extends EventEmitter<'update'> implements RelativeIndexable
 		return this.join(',');
 	}
 
-	public set(index: number, value: T): void {
+	protected _set(index: number, value: T, _delete: boolean = false) {
 		if (Math.abs(index) > this.data.size) {
 			throw new ReferenceError('Can not set an element outside the bounds of the list');
 		}
 
 		const data = Array.from(this.data);
-		data.splice(index, 1, value);
+		data.splice(index, +_delete, value);
 		this.data = new Set<T>(data);
 		this.emit('update');
 	}
 
+	public set(index: number, value: T): void {
+		this._set(index, value, true);
+	}
+
 	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');
@@ -47,6 +51,10 @@ export class List<T> extends EventEmitter<'update'> implements RelativeIndexable
 		this.delete(Array.from(this.data).at(index)!);
 	}
 
+	public insert(value: T, index: number = this.data.size) {
+		this._set(index, value, false);
+	}
+
 	// Array methods
 
 	public at(index: number): T {
@@ -115,12 +123,14 @@ export class List<T> extends EventEmitter<'update'> implements RelativeIndexable
 		return this.data.size;
 	}
 
-	public entries(): IterableIterator<[T, T]> {
-		return this.data.entries();
+	// Iteration
+
+	public entries(): IterableIterator<[number, T]> {
+		return this.toArray().entries();
 	}
 
-	public keys(): IterableIterator<T> {
-		return this.data.keys();
+	public keys(): IterableIterator<number> {
+		return this.toArray().keys();
 	}
 
 	public values(): IterableIterator<T> {

package/src/internal/struct-symbols.d.ts

@@ -1,4 +0,0 @@
-interface SymbolConstructor {
-	readonly struct_init: unique symbol;
-	readonly struct_metadata: unique symbol;
-}