@ovencord/util 1.1.7 → 1.1.8

package/package.json

@@ -1,7 +1,7 @@
 {
 	"$schema": "https://json.schemastore.org/package.json",
 	"name": "@ovencord/util",
-	"version": "1.1.7",
+	"version": "1.1.8",
 	"description": "Utilities shared across Discord.js packages",
 	"scripts": {
 		"test": "bun test",

package/src/AsyncEventEmitter.ts

@@ -3,201 +3,204 @@ import { AsyncQueue } from './AsyncQueue.js';
 export type EventMap = Record<string | symbol, any[]>;
 
 export class AsyncEventEmitter<Events extends Record<keyof Events, any[]> = any> {
-  private _listeners = new Map<keyof Events | string | symbol, Set<Function>>();
-  private _maxListeners = 10;
-
-  public on<K extends keyof Events>(event: K, listener: (...args: Events[K]) => void | Promise<void>): this;
-  public on<K extends string | symbol>(event: K, listener: (...args: any[]) => void | Promise<void>): this;
-  public on(event: string | symbol, listener: Function): this {
-    if (!this._listeners.has(event)) {
-      this._listeners.set(event, new Set());
-    }
-
-    const listeners = this._listeners.get(event)!;
-    listeners.add(listener);
-
-    if (listeners.size > this._maxListeners) {
-      console.warn(
-        `Possible AsyncEventEmitter memory leak detected. ` +
-        `${listeners.size} ${String(event)} listeners added. ` +
-        `Use emitter.setMaxListeners() to increase limit`
-      );
-    }
-
-    return this;
-  }
-
-  public addListener<K extends keyof Events>(event: K, listener: (...args: Events[K]) => void | Promise<void>): this;
-  public addListener<K extends string | symbol>(event: K, listener: (...args: any[]) => void | Promise<void>): this;
-  public addListener(event: string | symbol, listener: Function): this {
-    return this.on(event, listener as any);
-  }
-
-  public once<K extends keyof Events>(event: K, listener: (...args: Events[K]) => void | Promise<void>): this;
-  public once<K extends string | symbol>(event: K, listener: (...args: any[]) => void | Promise<void>): this;
-  public once(event: string | symbol, listener: Function): this {
-    const wrapper = async (...args: any[]) => {
-      this.off(event, wrapper);
-      await listener(...args);
-    };
-
-    Object.defineProperty(wrapper, '_originalListener', {
-      value: listener,
-      writable: false,
-      enumerable: false,
-    });
-
-    return this.on(event, wrapper);
-  }
-
-  public off<K extends keyof Events>(event: K, listener: (...args: Events[K]) => void | Promise<void>): this;
-  public off<K extends string | symbol>(event: K, listener: (...args: any[]) => void | Promise<void>): this;
-  public off(event: string | symbol, listener: Function): this {
-    const listeners = this._listeners.get(event);
-    if (!listeners) return this;
-
-    for (const fn of listeners) {
-      if (fn === listener || (fn as any)._originalListener === listener) {
-        listeners.delete(fn);
-      }
-    }
-
-    if (listeners.size === 0) {
-      this._listeners.delete(event);
-    }
-
-    return this;
-  }
-
-  public removeListener<K extends keyof Events>(event: K, listener: (...args: Events[K]) => void | Promise<void>): this;
-  public removeListener<K extends string | symbol>(event: K, listener: (...args: any[]) => void | Promise<void>): this;
-  public removeListener(event: string | symbol, listener: Function): this {
-    return this.off(event, listener as any);
-  }
-
-  public async emit<K extends keyof Events>(event: K, ...args: Events[K]): Promise<boolean>;
-  public async emit<K extends string | symbol>(event: K, ...args: any[]): Promise<boolean>;
-  public async emit(event: string | symbol, ...args: any[]): Promise<boolean> {
-    const listeners = this._listeners.get(event);
-    if (!listeners?.size) return false;
-
-    // We copy the listeners to ensure that if a listener is removed during execution,
-    // the loop still iterates over the snapshot of listeners at the time of emission.
-    // However, for strict sequential execution where one might remove another,
-    // iterating over the live Set or a copy is a design choice.
-    // Discord.js usually handles this by copying or iterating safe.
-    // The user's snippet iterates directly over the listeners collection from .get().
-    // If we use 'for of' on a Set, it handles deletions gracefully (the deleted item won't be visited if not reached yet),
-    // but additions might be visited.
-    // For now, adhering to user's "for (const listener of listeners)" pattern.
-    
-    // NOTE: Iterating over the Set directly allows listeners to remove themselves safely.
-    for (const listener of listeners) {
-      try {
-        await listener(...args);
-      } catch (error) {
-        if (event === 'error') {
-          console.error('Error in error handler:', error);
-        } else if (this.listenerCount('error') > 0) {
-          await this.emit('error', error);
-        } else {
-          console.error(`Unhandled error in ${String(event)} event:`, error);
-          throw error;
-        }
-      }
-    }
-
-    return true;
-  }
-
-  public removeAllListeners(event?: keyof Events | string | symbol): this {
-    if (event !== undefined) {
-      this._listeners.delete(event);
-    } else {
-      this._listeners.clear();
-    }
-    return this;
-  }
-
-  public setMaxListeners(n: number): this {
-    this._maxListeners = n;
-    return this;
-  }
-
-  public getMaxListeners(): number {
-    return this._maxListeners;
-  }
-
-  public listenerCount(event: keyof Events | string | symbol): number {
-    return this._listeners.get(event)?.size ?? 0;
-  }
-
-  public eventNames(): Array<keyof Events | string | symbol> {
-    return Array.from(this._listeners.keys());
-  }
-
-  public rawListeners(event: keyof Events | string | symbol): Function[] {
-    return Array.from(this._listeners.get(event) ?? []);
-  }
-
-  public waitFor<K extends keyof Events>(event: K, timeout?: number): Promise<Events[K]>;
-  public waitFor(event: string | symbol, timeout?: number): Promise<any[]> {
-    return new Promise((resolve, reject) => {
-      let timeoutId: Timer | undefined;
-
-      const listener = (...args: any[]) => {
-        if (timeoutId) clearTimeout(timeoutId);
-        resolve(args);
-      };
-
-      this.once(event, listener);
-
-      if (timeout) {
-        timeoutId = setTimeout(() => {
-          this.off(event, listener);
-          reject(new Error(`Timeout waiting for ${String(event)}`));
-        }, timeout);
-      }
-    });
-  }
-
-  public static async *on<T extends AsyncEventEmitter<any>, K extends keyof (T extends AsyncEventEmitter<infer U> ? U : never)>(
-    emitter: T,
-    eventName: K,
-    options?: { signal?: AbortSignal }
-  ): AsyncIterableIterator<(T extends AsyncEventEmitter<infer U> ? U : never)[K]> {
-    const signal = options?.signal;
-    if (signal?.aborted) throw new Error('AbortError');
-
-    const queue = new AsyncQueue();
-    const items: any[][] = [];
-
-    const listener = (...args: any[]) => {
-      items.push(args);
-      queue.shift();
-    };
-
-    const abortHandler = () => {
-      emitter.off(eventName as any, listener);
-      queue.shift();
-    };
-
-    emitter.on(eventName as any, listener);
-    signal?.addEventListener('abort', abortHandler, { once: true });
-
-    try {
-      while (true) {
-        if (signal?.aborted && items.length === 0) break;
-        if (items.length === 0) {
-          await queue.wait(options);
-        }
-        if (signal?.aborted && items.length === 0) break;
-
-        yield items.shift()! as any;
-      }
-    } finally {
-      emitter.off(eventName as any, listener);
-      signal?.removeEventListener('abort', abortHandler);
-    }
-  }
+	private _listeners = new Map<keyof Events | string | symbol, Set<Function>>();
+	private _maxListeners = 10;
+
+	public on<K extends keyof Events>(event: K, listener: (...args: Events[K]) => void | Promise<void>): this;
+	public on<K extends string | symbol>(event: K, listener: (...args: any[]) => void | Promise<void>): this;
+	public on(event: string | symbol, listener: Function): this {
+		if (!this._listeners.has(event)) {
+			this._listeners.set(event, new Set());
+		}
+
+		const listeners = this._listeners.get(event)!;
+		listeners.add(listener);
+
+		if (listeners.size > this._maxListeners) {
+			console.warn(
+				`Possible AsyncEventEmitter memory leak detected. ` +
+					`${listeners.size} ${String(event)} listeners added. ` +
+					`Use emitter.setMaxListeners() to increase limit`,
+			);
+		}
+
+		return this;
+	}
+
+	public addListener<K extends keyof Events>(event: K, listener: (...args: Events[K]) => void | Promise<void>): this;
+	public addListener<K extends string | symbol>(event: K, listener: (...args: any[]) => void | Promise<void>): this;
+	public addListener(event: string | symbol, listener: Function): this {
+		return this.on(event, listener as any);
+	}
+
+	public once<K extends keyof Events>(event: K, listener: (...args: Events[K]) => void | Promise<void>): this;
+	public once<K extends string | symbol>(event: K, listener: (...args: any[]) => void | Promise<void>): this;
+	public once(event: string | symbol, listener: Function): this {
+		const wrapper = async (...args: any[]) => {
+			this.off(event, wrapper);
+			await listener(...args);
+		};
+
+		Object.defineProperty(wrapper, '_originalListener', {
+			value: listener,
+			writable: false,
+			enumerable: false,
+		});
+
+		return this.on(event, wrapper);
+	}
+
+	public off<K extends keyof Events>(event: K, listener: (...args: Events[K]) => void | Promise<void>): this;
+	public off<K extends string | symbol>(event: K, listener: (...args: any[]) => void | Promise<void>): this;
+	public off(event: string | symbol, listener: Function): this {
+		const listeners = this._listeners.get(event);
+		if (!listeners) return this;
+
+		for (const fn of listeners) {
+			if (fn === listener || (fn as any)._originalListener === listener) {
+				listeners.delete(fn);
+			}
+		}
+
+		if (listeners.size === 0) {
+			this._listeners.delete(event);
+		}
+
+		return this;
+	}
+
+	public removeListener<K extends keyof Events>(event: K, listener: (...args: Events[K]) => void | Promise<void>): this;
+	public removeListener<K extends string | symbol>(event: K, listener: (...args: any[]) => void | Promise<void>): this;
+	public removeListener(event: string | symbol, listener: Function): this {
+		return this.off(event, listener as any);
+	}
+
+	public async emit<K extends keyof Events>(event: K, ...args: Events[K]): Promise<boolean>;
+	public async emit<K extends string | symbol>(event: K, ...args: any[]): Promise<boolean>;
+	public async emit(event: string | symbol, ...args: any[]): Promise<boolean> {
+		const listeners = this._listeners.get(event);
+		if (!listeners?.size) return false;
+
+		// We copy the listeners to ensure that if a listener is removed during execution,
+		// the loop still iterates over the snapshot of listeners at the time of emission.
+		// However, for strict sequential execution where one might remove another,
+		// iterating over the live Set or a copy is a design choice.
+		// Discord.js usually handles this by copying or iterating safe.
+		// The user's snippet iterates directly over the listeners collection from .get().
+		// If we use 'for of' on a Set, it handles deletions gracefully (the deleted item won't be visited if not reached yet),
+		// but additions might be visited.
+		// For now, adhering to user's "for (const listener of listeners)" pattern.
+
+		// NOTE: Iterating over the Set directly allows listeners to remove themselves safely.
+		for (const listener of listeners) {
+			try {
+				await listener(...args);
+			} catch (error) {
+				if (event === 'error') {
+					console.error('Error in error handler:', error);
+				} else if (this.listenerCount('error') > 0) {
+					await this.emit('error', error);
+				} else {
+					console.error(`Unhandled error in ${String(event)} event:`, error);
+					throw error;
+				}
+			}
+		}
+
+		return true;
+	}
+
+	public removeAllListeners(event?: keyof Events | string | symbol): this {
+		if (event !== undefined) {
+			this._listeners.delete(event);
+		} else {
+			this._listeners.clear();
+		}
+		return this;
+	}
+
+	public setMaxListeners(n: number): this {
+		this._maxListeners = n;
+		return this;
+	}
+
+	public getMaxListeners(): number {
+		return this._maxListeners;
+	}
+
+	public listenerCount(event: keyof Events | string | symbol): number {
+		return this._listeners.get(event)?.size ?? 0;
+	}
+
+	public eventNames(): Array<keyof Events | string | symbol> {
+		return Array.from(this._listeners.keys());
+	}
+
+	public rawListeners(event: keyof Events | string | symbol): Function[] {
+		return Array.from(this._listeners.get(event) ?? []);
+	}
+
+	public waitFor<K extends keyof Events>(event: K, timeout?: number): Promise<Events[K]>;
+	public waitFor(event: string | symbol, timeout?: number): Promise<any[]> {
+		return new Promise((resolve, reject) => {
+			let timeoutId: Timer | undefined;
+
+			const listener = (...args: any[]) => {
+				if (timeoutId) clearTimeout(timeoutId);
+				resolve(args);
+			};
+
+			this.once(event, listener);
+
+			if (timeout) {
+				timeoutId = setTimeout(() => {
+					this.off(event, listener);
+					reject(new Error(`Timeout waiting for ${String(event)}`));
+				}, timeout);
+			}
+		});
+	}
+
+	public static async *on<
+		T extends AsyncEventEmitter<any>,
+		K extends keyof (T extends AsyncEventEmitter<infer U> ? U : never),
+	>(
+		emitter: T,
+		eventName: K,
+		options?: { signal?: AbortSignal },
+	): AsyncIterableIterator<(T extends AsyncEventEmitter<infer U> ? U : never)[K]> {
+		const signal = options?.signal;
+		if (signal?.aborted) throw new Error('AbortError');
+
+		const queue = new AsyncQueue();
+		const items: any[][] = [];
+
+		const listener = (...args: any[]) => {
+			items.push(args);
+			queue.shift();
+		};
+
+		const abortHandler = () => {
+			emitter.off(eventName as any, listener);
+			queue.shift();
+		};
+
+		emitter.on(eventName as any, listener);
+		signal?.addEventListener('abort', abortHandler, { once: true });
+
+		try {
+			while (true) {
+				if (signal?.aborted && items.length === 0) break;
+				if (items.length === 0) {
+					await queue.wait(options);
+				}
+				if (signal?.aborted && items.length === 0) break;
+
+				yield items.shift()! as any;
+			}
+		} finally {
+			emitter.off(eventName as any, listener);
+			signal?.removeEventListener('abort', abortHandler);
+		}
+	}
 }

package/src/AsyncQueue.ts

@@ -17,7 +17,7 @@ export class AsyncQueue {
 	 * @param options.signal - An optional abort signal
 	 */
 	public wait(options?: { signal?: AbortSignal }): Promise<void> {
-		const next = this.#promises.length ? this.#promises.at(-1)!.promise : Promise.resolve();
+		const next = this.#promises.length ? this.#promises.at(-1)?.promise : Promise.resolve();
 
 		let resolve!: () => void;
 		const promise = new Promise<void>((res) => {
@@ -26,32 +26,32 @@ export class AsyncQueue {
 
 		this.#promises.push({ promise, resolve });
 
-        // If no signal, just return the promise we wait on
-        if (!options?.signal) {
-            return next;
-        }
+		// If no signal, just return the promise we wait on
+		if (!options?.signal) {
+			return next;
+		}
 
-        return new Promise((res, rej) => {
-            if (options.signal!.aborted) {
-                // Bridge immediately: when next resolves, we resolve our token
-                next.then(() => resolve());
-                rej(new Error('AbortError')); // TODO: Use DOMException or standard AbortError if available
-                return;
-            }
+		return new Promise((res, rej) => {
+			if (options.signal?.aborted) {
+				// Bridge immediately: when next resolves, we resolve our token
+				next.then(() => resolve());
+				rej(new Error('AbortError')); // TODO: Use DOMException or standard AbortError if available
+				return;
+			}
 
-            const abortHandler = () => {
-                // Bridge: when next resolves, we resolve our token
-                next.then(() => resolve());
-                rej(new Error('AbortError'));
-            };
+			const abortHandler = () => {
+				// Bridge: when next resolves, we resolve our token
+				next.then(() => resolve());
+				rej(new Error('AbortError'));
+			};
 
-            options.signal!.addEventListener('abort', abortHandler, { once: true });
+			options.signal?.addEventListener('abort', abortHandler, { once: true });
 
-            next.then(() => {
-                options.signal!.removeEventListener('abort', abortHandler);
-                res();
-            });
-        });
+			next.then(() => {
+				options.signal?.removeEventListener('abort', abortHandler);
+				res();
+			});
+		});
 	}
 
 	/**

package/src/RawFile.ts

@@ -1,4 +1,3 @@
-
 /**
  * Represents a file to be added to a request with multipart/form-data encoding
  */

package/src/Snowflake.ts

@@ -181,7 +181,15 @@ export class Snowflake {
 		const typeA = typeof a;
 		if (typeA === typeof b) {
 			if (typeA === 'string') {
-				return a === b ? 0 : (a as string).length < (b as string).length ? -1 : (a as string).length > (b as string).length ? 1 : a < b ? -1 : 1;
+				return a === b
+					? 0
+					: (a as string).length < (b as string).length
+						? -1
+						: (a as string).length > (b as string).length
+							? 1
+							: a < b
+								? -1
+								: 1;
 			}
 
 			return a === b ? 0 : (a as bigint) < (b as bigint) ? -1 : 1;

package/src/functions/runtime.ts

@@ -1,5 +1,3 @@
-
-
 export function shouldUseGlobalFetchAndWebSocket() {
 	// Browser env and deno when ran directly
 	if (typeof globalThis.process === 'undefined') {

package/src/functions/userAgentAppendix.ts

@@ -1,5 +1,3 @@
-
-
 /**
  * Resolves the user agent appendix string for the current environment.
  */
@@ -8,24 +6,24 @@ export function getUserAgentAppendix(): string {
 	if (typeof (globalThis as any).EdgeRuntime !== 'undefined') {
 		return 'Vercel-Edge-Functions';
 	}
- 
+
 	// Cloudflare Workers
 	if (typeof (globalThis as any).R2 !== 'undefined' && typeof (globalThis as any).WebSocketPair !== 'undefined') {
 		// https://developers.cloudflare.com/workers/runtime-apis/web-standards/#navigatoruseragent
 		return 'Cloudflare-Workers';
 	}
- 
+
 	// https://docs.netlify.com/edge-functions/api/#netlify-global-object
 	if (typeof (globalThis as any).Netlify !== 'undefined') {
 		return 'Netlify-Edge-Functions';
 	}
- 
+
 	// Most (if not all) edge environments will have `process` defined. Within a web browser we'll extract it using `navigator.userAgent`.
 	if (typeof (globalThis as any).process !== 'object') {
 		if (typeof (globalThis as any).navigator === 'object') {
 			return (globalThis as any).navigator.userAgent;
 		}
- 
+
 		return 'UnknownEnvironment';
 	}
 

package/src/index.ts

@@ -1,13 +1,13 @@
-export type * from './types.js';
-export { DiscordSnowflake, Snowflake as SnowflakeClass } from './Snowflake.js';
-export type { DeconstructedSnowflake, SnowflakeGenerateOptions } from './Snowflake.js';
-export * from './functions/index.js';
-export * from './encodables.js';
-export type * from './RawFile.js';
-export * from './Equatable.js';
-export * from './gatewayRateLimitError.js';
 export * from './AsyncEventEmitter.js';
 export * from './AsyncQueue.js';
+export * from './Equatable.js';
+export * from './encodables.js';
+export * from './functions/index.js';
+export * from './gatewayRateLimitError.js';
+export type * from './RawFile.js';
+export type { DeconstructedSnowflake, SnowflakeGenerateOptions } from './Snowflake.js';
+export { DiscordSnowflake, Snowflake as SnowflakeClass } from './Snowflake.js';
+export type * from './types.js';
 
 /**
  * The {@link https://github.com/ovencord/ovencord/blob/main/packages/util#readme | @ovencord/util} version

package/src/shims.d.ts

@@ -1,6 +1,6 @@
 /**
  * Type Shims for Bun Native Environment
- * 
+ *
  * This file provides type declarations to eliminate conflicts between
  * @types/node and @types/bun, allowing clean TypeScript compilation
  * in a pure Bun environment.
@@ -47,9 +47,9 @@ declare global {
 			platform: string;
 		}
 
-		interface Timeout extends Number {}
+		interface Timeout extends number {}
 	}
-	
+
 	// Global declarations
 	var process: NodeJS.Process;
 	var __dirname: string;