@ovencord/discord.js 14.16.14 → 14.16.15-dev.1

package/src/sharding/Shard.ts

@@ -1,17 +1,17 @@
 /* eslint-disable   no-use-before-define */
 
 import path from 'node:path';
-import process from 'node:process';
-import { setTimeout, clearTimeout  } from 'node:timers';
-import { setTimeout as sleep  } from 'node:timers/promises';
 import { SHARE_ENV  } from 'node:worker_threads';
-import { AsyncEventEmitter  } from '@vladfrangu/async_event_emitter';
+import { AsyncEventEmitter  } from '../util/AsyncEventEmitter.js';
 import { DiscordjsError, ErrorCodes  } from '../errors/index.js';
 import { ShardEvents  } from '../util/ShardEvents.js';
 import { makeError, makePlainError  } from '../util/Util.js';
 
-let childProcess = null;
-let Worker = null;
+import type { ChildProcess } from 'node:child_process';
+import type { Worker as WorkerThread } from 'node:worker_threads';
+
+let childProcess: typeof import('node:child_process') | null = null;
+let Worker: typeof WorkerThread | null = null;
 
 /**
  * A self-contained shard created by the {@link ShardingManager}. Each one has a {@link ChildProcess} that contains
@@ -27,11 +27,13 @@ export class Shard extends AsyncEventEmitter {
   public args: any;
   public execArgv: any;
   public env: any;
-  public worker: any;
+  public worker: WorkerThread | null = null;
+  public process: ChildProcess | null = null;
+  public ready: boolean = false;
   public _evals: any;
   public _fetches: any;
   public _exitListener: any;
-  constructor(manager, id) {
+  constructor(manager: any, id: any) {
     super();
 
     switch (manager.mode) {
@@ -155,14 +157,13 @@ export class Shard extends AsyncEventEmitter {
 
     switch (this.manager.mode) {
       case 'process':
-        this.process = childProcess
-          .fork(path.resolve(this.manager.file), this.args, {
-            env: this.env,
-            execArgv: this.execArgv,
-            silent: this.silent,
-          })
-          .on('message', this._handleMessage.bind(this))
-          .on('exit', this._exitListener);
+        this.process = childProcess.fork(path.resolve(this.manager.file), this.args, {
+          env: this.env,
+          execArgv: this.execArgv,
+          silent: this.silent,
+        });
+        (this.process as any).on('message', this._handleMessage.bind(this));
+        (this.process as any).on('exit', this._exitListener);
         break;
       case 'worker':
         this.worker = new Worker(path.resolve(this.manager.file), {
@@ -170,9 +171,9 @@ export class Shard extends AsyncEventEmitter {
           env: SHARE_ENV,
           execArgv: this.execArgv,
           argv: this.args,
-        })
-          .on('message', this._handleMessage.bind(this))
-          .on('exit', this._exitListener);
+        });
+        (this.worker as any).on('message', this._handleMessage.bind(this));
+        (this.worker as any).on('exit', this._exitListener);
         break;
       default:
         break;
@@ -232,11 +233,11 @@ export class Shard extends AsyncEventEmitter {
    */
   kill() {
     if (this.process) {
-      this.process.removeListener('exit', this._exitListener);
+      (this.process as any).removeListener('exit', this._exitListener);
       this.process.kill();
     } else {
-      this.worker.removeListener('exit', this._exitListener);
-      this.worker.terminate();
+      (this.worker as any).removeListener('exit', this._exitListener);
+      (this.worker as any).terminate();
     }
 
     this._handleExit(false);
@@ -260,7 +261,7 @@ export class Shard extends AsyncEventEmitter {
    */
   async respawn({ delay = 500, timeout = 30_000 } = {}) {
     this.kill();
-    if (delay > 0) await sleep(delay);
+    if (delay > 0) await Bun.sleep(delay);
     return this.spawn(timeout);
   }
 
@@ -270,15 +271,15 @@ export class Shard extends AsyncEventEmitter {
    * @param {*} message Message to send to the shard
    * @returns {Promise<Shard>}
    */
-  async send(message) {
+  async send(message: any): Promise<Shard> {
     return new Promise((resolve, reject) => {
       if (this.process) {
-        this.process.send(message, err => {
+        (this.process as any).send(message, (err: Error | null) => {
           if (err) reject(err);
           else resolve(this);
         });
       } else {
-        this.worker.postMessage(message);
+        (this.worker as any).postMessage(message);
         resolve(this);
       }
     });
@@ -294,7 +295,7 @@ export class Shard extends AsyncEventEmitter {
    *   .then(count => console.log(`${count} guilds in shard ${shard.id}`))
    *   .catch(console.error);
    */
-  async fetchClientValue(prop) {
+  async fetchClientValue(prop: any): Promise<any> {
     // Shard is dead (maybe respawning), don't cache anything and error immediately
     if (!this.process && !this.worker) {
       throw new DiscordjsError(ErrorCodes.ShardingNoChildExists, this.id);
@@ -306,9 +307,9 @@ export class Shard extends AsyncEventEmitter {
     const promise = new Promise((resolve, reject) => {
       const child = this.process ?? this.worker;
 
-      const listener = message => {
+      const listener = (message: any) => {
         if (message?._fetchProp !== prop) return;
-        child.removeListener('message', listener);
+        (child as any).removeListener('message', listener);
         this.decrementMaxListeners(child);
         this._fetches.delete(prop);
         if (message._error) reject(makeError(message._error));
@@ -316,10 +317,10 @@ export class Shard extends AsyncEventEmitter {
       };
 
       this.incrementMaxListeners(child);
-      child.on('message', listener);
+      (child as any).on('message', listener);
 
       this.send({ _fetchProp: prop }).catch(error => {
-        child.removeListener('message', listener);
+        (child as any).removeListener('message', listener);
         this.decrementMaxListeners(child);
         this._fetches.delete(prop);
         reject(error);
@@ -337,7 +338,7 @@ export class Shard extends AsyncEventEmitter {
    * @param {*} [context] The context for the eval
    * @returns {Promise<*>} Result of the script execution
    */
-  async eval(script, context) {
+  async eval(script: any, context?: any): Promise<any> {
     // Stringify the script if it's a Function
     const _eval = typeof script === 'function' ? `(${script})(this, ${JSON.stringify(context)})` : script;
 
@@ -352,9 +353,9 @@ export class Shard extends AsyncEventEmitter {
     const promise = new Promise((resolve, reject) => {
       const child = this.process ?? this.worker;
 
-      const listener = message => {
+      const listener = (message: any) => {
         if (message?._eval !== _eval) return;
-        child.removeListener('message', listener);
+        (child as any).removeListener('message', listener);
         this.decrementMaxListeners(child);
         this._evals.delete(_eval);
         if (message._error) reject(makeError(message._error));
@@ -362,10 +363,10 @@ export class Shard extends AsyncEventEmitter {
       };
 
       this.incrementMaxListeners(child);
-      child.on('message', listener);
+      (child as any).on('message', listener);
 
       this.send({ _eval }).catch(error => {
-        child.removeListener('message', listener);
+        (child as any).removeListener('message', listener);
         this.decrementMaxListeners(child);
         this._evals.delete(_eval);
         reject(error);
@@ -382,7 +383,7 @@ export class Shard extends AsyncEventEmitter {
    * @param {*} message Message received
    * @private
    */
-  _handleMessage(message) {
+  _handleMessage(message: any): void {
     if (message) {
       // Shard is ready
       if (message._ready) {

package/src/sharding/ShardClientUtil.ts

@@ -1,6 +1,4 @@
 /* eslint-disable   */
-
-import process from 'node:process';
 import { calculateShardId  } from '@ovencord/util';
 import { WebSocketShardEvents  } from '@ovencord/ws';
 import { DiscordjsError, DiscordjsTypeError, ErrorCodes  } from '../errors/index.js';
@@ -15,8 +13,9 @@ export class ShardClientUtil {
   public client: any;
   public mode: any;
   public parentPort: any;
-  public _singleton: any;
-  constructor(client, mode) {
+  private static _singleton: ShardClientUtil | null = null;
+  
+  constructor(client: any, mode: any) {
     /**
      * Client for the shard
      *
@@ -76,18 +75,18 @@ export class ShardClientUtil {
    * @returns {Promise<void>}
    * @emits Shard#message
    */
-  async send(message) {
+  async send(message: any): Promise<void> {
     return new Promise((resolve, reject) => {
       switch (this.mode) {
         case 'process':
-          process.send(message, err => {
+          process.send!(message, (err: Error | null) => {
             if (err) reject(err);
-            else resolve();
+            else resolve(undefined);
           });
           break;
         case 'worker':
           this.parentPort.postMessage(message);
-          resolve();
+          resolve(undefined);
           break;
         default:
           break;
@@ -107,11 +106,11 @@ export class ShardClientUtil {
    *   .catch(console.error);
    * @see {@link ShardingManager#fetchClientValues}
    */
-  async fetchClientValues(prop, shard) {
+  async fetchClientValues(prop: any, shard: any): Promise<any> {
     return new Promise((resolve, reject) => {
       const parent = this.parentPort ?? process;
 
-      const listener = message => {
+      const listener = (message: any) => {
         if (message?._sFetchProp !== prop || message._sFetchPropShard !== shard) return;
         parent.removeListener('message', listener);
         this.decrementMaxListeners(parent);
@@ -142,7 +141,7 @@ export class ShardClientUtil {
    *   .catch(console.error);
    * @see {@link ShardingManager#broadcastEval}
    */
-  async broadcastEval(script, options = {}) {
+  async broadcastEval(script: any, options: any = {}): Promise<any> {
     return new Promise((resolve, reject) => {
       const parent = this.parentPort ?? process;
       if (typeof script !== 'function') {
@@ -152,7 +151,7 @@ export class ShardClientUtil {
 
       const evalScript = `(${script})(this, ${JSON.stringify(options.context)})`;
 
-      const listener = message => {
+      const listener = (message: any) => {
         if (message?._sEval !== evalScript || message._sEvalShard !== options.shard) return;
         parent.removeListener('message', listener);
         this.decrementMaxListeners(parent);
@@ -177,7 +176,7 @@ export class ShardClientUtil {
    * @returns {Promise<void>} Resolves upon the message being sent
    * @see {@link ShardingManager#respawnAll}
    */
-  async respawnAll({ shardDelay = 5_000, respawnDelay = 500, timeout = 30_000 } = {}) {
+  async respawnAll({ shardDelay = 5_000, respawnDelay = 500, timeout = 30_000 } = {}): Promise<void> {
     return this.send({ _sRespawnAll: { shardDelay, respawnDelay, timeout } });
   }
 
@@ -187,7 +186,7 @@ export class ShardClientUtil {
    * @param {*} message Message received
    * @private
    */
-  async _handleMessage(message) {
+  async _handleMessage(message: any): Promise<void> {
     if (!message) return;
     if (message._fetchProp) {
       try {
@@ -214,7 +213,7 @@ export class ShardClientUtil {
    * @param {*} message Message to send
    * @private
    */
-  _respond(type, message) {
+  _respond(type: string, message: any): void {
     this.send(message).catch(error_ => {
       const error = new Error(`Error when sending ${type} response to master process: ${error_.message}`);
       error.stack = error_.stack;
@@ -239,7 +238,7 @@ export class ShardClientUtil {
    * @param {ShardingManagerMode} mode Mode the shard was spawned with
    * @returns {ShardClientUtil}
    */
-  static singleton(client, mode) {
+  static singleton(client: any, mode: any): ShardClientUtil {
     if (this._singleton) {
       client.emit(
         Events.Warn,
@@ -259,7 +258,7 @@ export class ShardClientUtil {
    * @param {number} shardCount Number of shards
    * @returns {number}
    */
-  static shardIdForGuildId(guildId, shardCount) {
+  static shardIdForGuildId(guildId: string, shardCount: number): number {
     const shard = calculateShardId(guildId, shardCount);
     if (shard < 0) throw new DiscordjsError(ErrorCodes.ShardingShardMiscalculation, shard, guildId, shardCount);
     return shard;
@@ -271,7 +270,7 @@ export class ShardClientUtil {
    * @param {Worker|ChildProcess} emitter The emitter that emits the events.
    * @private
    */
-  incrementMaxListeners(emitter) {
+  incrementMaxListeners(emitter: any): void {
     const maxListeners = emitter.getMaxListeners();
     if (maxListeners !== 0) {
       emitter.setMaxListeners(maxListeners + 1);
@@ -284,7 +283,7 @@ export class ShardClientUtil {
    * @param {Worker|ChildProcess} emitter The emitter that emits the events.
    * @private
    */
-  decrementMaxListeners(emitter) {
+  decrementMaxListeners(emitter: any): void {
     const maxListeners = emitter.getMaxListeners();
     if (maxListeners !== 0) {
       emitter.setMaxListeners(maxListeners - 1);

package/src/sharding/ShardingManager.ts

@@ -1,10 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import process from 'node:process';
-import { setTimeout as sleep  } from 'node:timers/promises';
 import { Collection  } from '@ovencord/collection';
 import { range  } from '@ovencord/util';
-import { AsyncEventEmitter  } from '@vladfrangu/async_event_emitter';
+import { AsyncEventEmitter  } from '../util/AsyncEventEmitter.js';
 import { DiscordjsError, DiscordjsTypeError, DiscordjsRangeError, ErrorCodes  } from '../errors/index.js';
 import { fetchRecommendedShardCount  } from '../util/Util.js';
 import { Shard  } from './Shard.js';
@@ -24,10 +22,12 @@ export class ShardingManager extends AsyncEventEmitter {
   public shardList: any;
   public totalShards: any;
   public mode: any;
+  public respawn: boolean;
   public silent: any;
   public shardArgs: any;
   public execArgv: any;
   public token: any;
+  public shards: any;
   /**
    * The mode to spawn shards with for a {@link ShardingManager}. Can be either one of:
    * - 'process' to use child processes
@@ -55,7 +55,7 @@ export class ShardingManager extends AsyncEventEmitter {
    * @param {string} file Path to your shard script file
    * @param {ShardingManagerOptions} [options] Options for the sharding manager
    */
-  constructor(file, options) {
+  constructor(file: any, options?: any) {
     super();
     const _options = {
       totalShards: 'auto',
@@ -261,7 +261,7 @@ export class ShardingManager extends AsyncEventEmitter {
       const promises = [];
       const shard = this.createShard(shardId);
       promises.push(shard.spawn(timeout));
-      if (delay > 0 && this.shards.size !== this.shardList.length) promises.push(sleep(delay));
+      if (delay > 0 && this.shards.size !== this.shardList.length) promises.push(Bun.sleep(delay));
       await Promise.all(promises);
     }
 
@@ -295,7 +295,7 @@ export class ShardingManager extends AsyncEventEmitter {
    * @param {BroadcastEvalOptions} [options={}] The options for the broadcast
    * @returns {Promise<*|Array<*>>} Results of the script execution
    */
-  async broadcastEval(script, options = {}) {
+  async broadcastEval(script: any, options: any = {}): Promise<any> {
     if (typeof script !== 'function') {
       throw new DiscordjsTypeError(ErrorCodes.ShardingInvalidEvalBroadcast);
     }
@@ -365,7 +365,7 @@ export class ShardingManager extends AsyncEventEmitter {
     let shardCounter = 0;
     for (const shard of this.shards.values()) {
       const promises = [shard.respawn({ delay: respawnDelay, timeout })];
-      if (++shardCounter < this.shards.size && shardDelay > 0) promises.push(sleep(shardDelay));
+      if (++shardCounter < this.shards.size && shardDelay > 0) promises.push(Bun.sleep(shardDelay));
       await Promise.all(promises);
     }
 

package/src/structures/AnonymousGuild.ts

@@ -7,7 +7,6 @@ import { BaseGuild  } from './BaseGuild.js';
  * @abstract
  */
 export class AnonymousGuild extends BaseGuild {
-  public client: any;
   public features: any;
   public description: any;
   public verificationLevel: any;

package/src/structures/BaseGuild.ts

@@ -10,7 +10,6 @@ import { Base  } from './Base.js';
  * @abstract
  */
 export class BaseGuild extends Base {
-  public client: any;
   public id: any;
   public name: any;
   public features: any;

package/src/structures/Guild.ts

@@ -38,7 +38,6 @@ import { WelcomeScreen  } from './WelcomeScreen.js';
  * @extends {AnonymousGuild}
  */
 export class Guild extends AnonymousGuild {
-  public client: any;
   public commands: any;
   public members: any;
   public channels: any;

package/src/structures/interfaces/Collector.ts

@@ -1,6 +1,6 @@
 import { setTimeout, clearTimeout  } from 'node:timers';
 import { Collection  } from '@ovencord/collection';
-import { AsyncEventEmitter  } from '@vladfrangu/async_event_emitter';
+import { AsyncEventEmitter  } from '../../util/AsyncEventEmitter.js';
 import { DiscordjsTypeError, ErrorCodes  } from '../../errors/index.js';
 import { flatten  } from '../../util/Util.js';
 

package/src/util/AsyncEventEmitter.ts

@@ -0,0 +1,150 @@
+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 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 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/util/Partials.ts

@@ -47,4 +47,4 @@ export const Partials = createEnum([
   'Poll',
   'PollAnswer',
   'SoundboardSound',
-]);
+]) as any;

package/src/util/Status.ts

@@ -1,16 +1,6 @@
 
-import { createEnum  } from './Enums.js';
-
-/**
- * @typedef {Object} Status
- * @property {number} Ready ready
- * @property {number} Idle idle
- * @property {number} WaitingForGuilds waiting for guilds
- */
-
-// JSDoc for IntelliSense purposes
-/**
- * @type {Status}
- * @ignore
- */
-export const Status = createEnum(['Ready', 'Idle', 'WaitingForGuilds']);
+export enum Status {
+  Ready,
+  Idle,
+  WaitingForGuilds,
+}