@ovencord/util 1.1.2 → 1.1.4

package/package.json

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

package/src/AsyncEventEmitter.ts

@@ -1,28 +1,162 @@
-import { EventEmitter } from 'node:events';
-
-/**
- * A typed EventEmitter shim to replace @vladfrangu/async_event_emitter
- * This version uses the native node:events EventEmitter.
- * Note: strict async emission (awaiting listeners) is not implemented as it was not used by the library internally.
- */
-export class AsyncEventEmitter<TEvents extends { [K in keyof TEvents]: any[] }> extends EventEmitter {
-	public override on<K extends keyof TEvents & string>(event: K, listener: (...args: TEvents[K]) => void): this {
-		return super.on(event, listener as any);
-	}
-
-	public override once<K extends keyof TEvents & string>(event: K, listener: (...args: TEvents[K]) => void): this {
-		return super.once(event, listener as any);
-	}
-
-	public override emit<K extends keyof TEvents & string>(event: K, ...args: TEvents[K]): boolean {
-		return super.emit(event, ...args);
-	}
-
-	public override off<K extends keyof TEvents & string>(event: K, listener: (...args: TEvents[K]) => void): this {
-		return super.off(event, listener as any);
-	}
-
-    public override removeListener<K extends keyof TEvents & string>(event: K, listener: (...args: TEvents[K]) => void): this {
-        return super.removeListener(event, listener as any);
+export type EventMap = Record<string | symbol, any[]>;
+
+export class AsyncEventEmitter<Events extends EventMap = EventMap> {
+  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<K extends string | symbol>(event: K, timeout?: number): Promise<any[]>;
+  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);
+      }
+    });
+  }
 }

package/src/Snowflake.ts

@@ -0,0 +1,201 @@
+/**
+ * Options for {@link Snowflake.generate}
+ */
+export interface SnowflakeGenerateOptions {
+	/**
+	 * Timestamp or date of the snowflake to generate
+	 * @default Date.now()
+	 */
+	timestamp?: number | bigint | Date;
+
+	/**
+	 * The increment to use
+	 * @default 0n
+	 * @remark keep in mind that this bigint is auto-incremented between generate calls
+	 */
+	increment?: bigint;
+
+	/**
+	 * The worker ID to use, will be truncated to 5 bits (0-31)
+	 * @default 0n
+	 */
+	workerId?: bigint;
+
+	/**
+	 * The process ID to use, will be truncated to 5 bits (0-31)
+	 * @default 1n
+	 */
+	processId?: bigint;
+}
+
+/**
+ * Object returned by {@link Snowflake.deconstruct}
+ */
+export interface DeconstructedSnowflake {
+	/** The id in BigInt form */
+	id: bigint;
+	/** The timestamp stored in the snowflake */
+	timestamp: bigint;
+	/** The worker id stored in the snowflake */
+	workerId: bigint;
+	/** The process id stored in the snowflake */
+	processId: bigint;
+	/** The increment stored in the snowflake */
+	increment: bigint;
+	/** The epoch to use in the snowflake */
+	epoch: bigint;
+}
+
+const MaximumWorkerId = 0b11111n;
+const MaximumProcessId = 0b11111n;
+const MaximumIncrement = 0b111111111111n;
+const TimestampFieldDivisor = 2 ** 22;
+
+/**
+ * A class for generating and deconstructing snowflakes.
+ *
+ * A snowflake is a 64-bit unsigned integer with 4 fields that have a fixed epoch value.
+ *
+ * ```
+ * 64                                          22     17     12          0
+ *  000000111011000111100001101001000101000000  00001  00000  000000000000
+ *           number of ms since epoch           worker  pid    increment
+ * ```
+ */
+export class Snowflake {
+	/** Alias for {@link deconstruct} */
+	public readonly decode = this.deconstruct.bind(this);
+
+	#epoch: bigint;
+	#epochNumber: number;
+	#increment = 0n;
+	#processId = 1n;
+	#workerId = 0n;
+
+	/**
+	 * @param epoch the epoch to use
+	 */
+	constructor(epoch: number | bigint | Date) {
+		this.#epoch = BigInt(epoch instanceof Date ? epoch.getTime() : epoch);
+		this.#epochNumber = Number(this.#epoch);
+	}
+
+	/** The epoch for this snowflake, as a bigint */
+	get epoch(): bigint {
+		return this.#epoch;
+	}
+
+	/** The epoch for this snowflake, as a number */
+	get epochNumber(): number {
+		return this.#epochNumber;
+	}
+
+	/** Gets the configured process ID */
+	get processId(): bigint {
+		return this.#processId;
+	}
+
+	/** Sets the process ID (masked with `0b11111n`) */
+	set processId(value: number | bigint) {
+		this.#processId = BigInt(value) & MaximumProcessId;
+	}
+
+	/** Gets the configured worker ID */
+	get workerId(): bigint {
+		return this.#workerId;
+	}
+
+	/** Sets the worker ID (masked with `0b11111n`) */
+	set workerId(value: number | bigint) {
+		this.#workerId = BigInt(value) & MaximumWorkerId;
+	}
+
+	/**
+	 * Generates a snowflake given an epoch and optionally a timestamp.
+	 *
+	 * @param options - Options to pass into the generator
+	 * @returns A unique snowflake
+	 */
+	generate({
+		increment,
+		timestamp = Date.now(),
+		workerId = this.#workerId,
+		processId = this.#processId,
+	}: SnowflakeGenerateOptions = {}): bigint {
+		if (timestamp instanceof Date) timestamp = BigInt(timestamp.getTime());
+		else if (typeof timestamp === 'number') timestamp = BigInt(timestamp);
+		else if (typeof timestamp !== 'bigint') {
+			throw new TypeError(`"timestamp" argument must be a number, bigint, or Date (received ${typeof timestamp})`);
+		}
+
+		if (typeof increment !== 'bigint') {
+			increment = this.#increment;
+			this.#increment = (increment + 1n) & MaximumIncrement;
+		}
+
+		return (
+			((timestamp - this.#epoch) << 22n) |
+			((workerId & MaximumWorkerId) << 17n) |
+			((processId & MaximumProcessId) << 12n) |
+			(increment & MaximumIncrement)
+		);
+	}
+
+	/**
+	 * Deconstructs a snowflake given a snowflake ID.
+	 *
+	 * @param id - The snowflake to deconstruct
+	 * @returns A deconstructed snowflake
+	 */
+	deconstruct(id: string | bigint): DeconstructedSnowflake {
+		const bigIntId = BigInt(id);
+		const epoch = this.#epoch;
+		return {
+			id: bigIntId,
+			timestamp: (bigIntId >> 22n) + epoch,
+			workerId: (bigIntId >> 17n) & MaximumWorkerId,
+			processId: (bigIntId >> 12n) & MaximumProcessId,
+			increment: bigIntId & MaximumIncrement,
+			epoch,
+		};
+	}
+
+	/**
+	 * Retrieves the timestamp field's value from a snowflake.
+	 *
+	 * @param id - The snowflake to get the timestamp value from
+	 * @returns The UNIX timestamp that is stored in `id`
+	 */
+	timestampFrom(id: string | bigint): number {
+		return Math.floor(Number(id) / TimestampFieldDivisor) + this.#epochNumber;
+	}
+
+	/**
+	 * Compares two snowflakes.
+	 *
+	 * @param a - The first snowflake to compare
+	 * @param b - The second snowflake to compare
+	 * @returns `-1` if `a` is older than `b`, `0` if equal, `1` if `a` is newer than `b`
+	 */
+	static compare(a: string | bigint, b: string | bigint): -1 | 0 | 1 {
+		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 bigint) < (b as bigint) ? -1 : 1;
+		}
+
+		const bigA = BigInt(a);
+		const bigB = BigInt(b);
+		return bigA === bigB ? 0 : bigA < bigB ? -1 : 1;
+	}
+}
+
+/**
+ * A {@link Snowflake} instance using Discord's epoch (2015-01-01T00:00:00.000Z).
+ *
+ * @see {@link https://discord.com/developers/docs/reference#snowflakes}
+ */
+export const DiscordSnowflake = new Snowflake(1420070400000n);

package/src/functions/userAgentAppendix.ts

@@ -5,29 +5,27 @@
  */
 export function getUserAgentAppendix(): string {
 	// https://vercel.com/docs/concepts/functions/edge-functions/edge-runtime#check-if-you're-running-on-the-edge-runtime
-	// @ts-expect-error Vercel Edge functions
-	if (typeof globalThis.EdgeRuntime !== 'undefined') {
+	if (typeof (globalThis as any).EdgeRuntime !== 'undefined') {
 		return 'Vercel-Edge-Functions';
 	}
-
-	// @ts-expect-error Cloudflare Workers
-	if (typeof globalThis.R2 !== 'undefined' && typeof globalThis.WebSocketPair !== 'undefined') {
+ 
+	// 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
-	// @ts-expect-error Netlify Edge functions
-	if (typeof globalThis.Netlify !== 'undefined') {
+	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.process !== 'object') {
-		if (typeof globalThis.navigator === 'object') {
-			return globalThis.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,4 +1,6 @@
 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';