@ovencord/ws 2.0.2 → 2.0.4

package/package.json

@@ -1,7 +1,7 @@
 {
 	"$schema": "https://json.schemastore.org/package.json",
 	"name": "@ovencord/ws",
-	"version": "2.0.2",
+	"version": "2.0.4",
 	"description": "Wrapper around Discord's gateway",
 	"scripts": {
 		"test": "bun test",

package/src/strategies/sharding/IShardingStrategy.ts

@@ -27,4 +27,8 @@ export interface IShardingStrategy {
 	 * Spawns all the shards
 	 */
 	spawn(shardIds: number[]): Awaitable<void>;
+	/**
+	 * Gets all the shards managed by this strategy
+	 */
+	getShards(): Awaitable<Collection<number, { ping?: number; status: WebSocketShardStatus }>>;
 }

package/src/strategies/sharding/SimpleShardingStrategy.ts

@@ -81,4 +81,14 @@ export class SimpleShardingStrategy implements IShardingStrategy {
 	public async fetchStatus() {
 		return this.shards.mapValues((shard) => shard.status);
 	}
+
+	/**
+	 * {@inheritDoc IShardingStrategy.getShards}
+	 */
+	public async getShards() {
+		return this.shards.mapValues((shard) => ({
+			ping: shard.ping,
+			status: shard.status,
+		}));
+	}
 }

package/src/strategies/sharding/WorkerShardingStrategy.ts

@@ -22,6 +22,11 @@ export class WorkerShardingStrategy implements IShardingStrategy {
 		this.options = options;
 	}
 
+	public async getShards(): Promise<Collection<number, { ping?: number; status: WebSocketShardStatus; }>> {
+		const statuses = await this.fetchStatus();
+		return statuses.mapValues((status) => ({ status }));
+	}
+
 
 	public async spawn(shardIds: number[]) {
 		for (const shardId of shardIds) {

package/src/utils/constants.ts

@@ -1,9 +1,9 @@
 import { Collection } from '@ovencord/collection';
 import { lazy } from '@ovencord/util';
-import { APIVersion, GatewayOpcodes } from 'discord-api-types/v10';
+import { APIVersion, GatewayOpcodes, type GatewayPresenceUpdateData } from 'discord-api-types/v10';
 import { SimpleShardingStrategy } from '../strategies/sharding/SimpleShardingStrategy.js';
 import { SimpleIdentifyThrottler } from '../throttling/SimpleIdentifyThrottler.js';
-import type { SessionInfo, OptionalWebSocketManagerOptions, WebSocketManager } from '../ws/WebSocketManager.js';
+import type { SessionInfo, OptionalWebSocketManagerOptions, WebSocketManager, ShardRange } from '../ws/WebSocketManager.js';
 import type { SendRateLimitState } from '../ws/WebSocketShard.js';
 
 /**
@@ -40,11 +40,11 @@ export const DefaultWebSocketManagerOptions = {
 		const info = await manager.fetchGatewayInformation();
 		return new SimpleIdentifyThrottler(info.session_start_limit.max_concurrency);
 	},
-	buildStrategy: (manager) => new SimpleShardingStrategy(manager),
-	shardCount: null,
-	shardIds: null,
-	largeThreshold: null,
-	initialPresence: null,
+	buildStrategy: (manager: WebSocketManager) => new SimpleShardingStrategy(manager),
+	shardCount: null as number | null,
+	shardIds: null as number[] | ShardRange | null,
+	largeThreshold: null as number | null,
+	initialPresence: null as GatewayPresenceUpdateData | null,
 	identifyProperties: {
 		browser: DefaultDeviceProperty,
 		device: DefaultDeviceProperty,
@@ -52,9 +52,9 @@ export const DefaultWebSocketManagerOptions = {
 	},
 	version: APIVersion,
 	encoding: Encoding.JSON,
-	compression: null,
+	compression: null as CompressionMethod | null,
 	useIdentifyCompression: false,
-	retrieveSessionInfo(shardId) {
+	retrieveSessionInfo(shardId: number) {
 		const store = getDefaultSessionStore();
 		return store.get(shardId) ?? null;
 	},

package/src/ws/WebSocketManager.ts

@@ -13,7 +13,7 @@ import type {
 import type { IShardingStrategy } from '../strategies/sharding/IShardingStrategy.js';
 import type { IIdentifyThrottler } from '../throttling/IIdentifyThrottler.js';
 import { DefaultWebSocketManagerOptions, type CompressionMethod, type Encoding } from '../utils/constants.js';
-import type { WebSocketShardDestroyOptions, WebSocketShardEvents, WebSocketShardStatus } from './WebSocketShard.js';
+import { WebSocketShardStatus, type WebSocketShardDestroyOptions, type WebSocketShardEvents } from './WebSocketShard.js';
 
 /**
  * Represents a range of shard ids
@@ -264,6 +264,32 @@ export class WebSocketManager extends AsyncEventEmitter<ManagerShardEventsMap> i
 		return this.#token;
 	}
 
+	/**
+	 * Gets the average ping of all active shards
+	 *
+	 * @returns The average ping in milliseconds, or -1 if no shards are ready
+	 */
+	public get ping(): number {
+		return -1; // Will be calculated asynchronously
+	}
+
+	/**
+	 * Gets the average ping of all active shards asynchronously
+	 *
+	 * @returns The average ping in milliseconds, or -1 if no shards are ready
+	 */
+	public async getPing(): Promise<number> {
+		const shards = await this.strategy.getShards();
+		const activeShards = [...shards.values()].filter(
+			(shard) => shard.status === WebSocketShardStatus.Ready && shard.ping !== undefined && shard.ping >= 0
+		);
+
+		if (activeShards.length === 0) return -1;
+
+		const totalPing = activeShards.reduce((sum, shard) => sum + (shard.ping ?? 0), 0);
+		return Math.round(totalPing / activeShards.length);
+	}
+
 	public constructor(options: CreateWebSocketManagerOptions) {
 		if (typeof options.fetchGatewayInformation !== 'function') {
 			throw new TypeError('fetchGatewayInformation is required');

package/src/ws/WebSocketShard.ts

@@ -98,6 +98,13 @@ export class WebSocketShard extends AsyncEventEmitter<WebSocketShardEventsMap> {
 
 	private lastHeartbeatAt = -1;
 
+	public lastPingTimestamp = -1;
+
+	/**
+	 * The latency of the last heartbeat in milliseconds
+	 */
+	public ping = -1;
+
 	// Indicates whether the shard has already resolved its original connect() call
 	private initialConnectResolved = false;
 
@@ -510,6 +517,8 @@ export class WebSocketShard extends AsyncEventEmitter<WebSocketShardEventsMap> {
 
 		const session = await this.strategy.retrieveSessionInfo(this.id);
 
+		this.lastPingTimestamp = Number(Bun.nanoseconds());
+
 		await this.send({
 			op: GatewayOpcodes.Heartbeat,
 			 
@@ -689,10 +698,13 @@ export class WebSocketShard extends AsyncEventEmitter<WebSocketShardEventsMap> {
 				this.isAck = true;
 
 				const ackAt = Date.now();
+				const latency = Math.round((Number(Bun.nanoseconds()) - this.lastPingTimestamp) / 1_000_000);
+				this.ping = latency;
+				
 				this.emit(WebSocketShardEvents.HeartbeatComplete, {
 					ackAt,
 					heartbeatAt: this.lastHeartbeatAt,
-					latency: ackAt - this.lastHeartbeatAt,
+					latency,
 				});
 
 				break;