diff options
Diffstat (limited to 'node_modules/@discordjs/ws/dist/defaultWorker.js')
| -rw-r--r-- | node_modules/@discordjs/ws/dist/defaultWorker.js | 1051 |
1 files changed, 1051 insertions, 0 deletions
diff --git a/node_modules/@discordjs/ws/dist/defaultWorker.js b/node_modules/@discordjs/ws/dist/defaultWorker.js new file mode 100644 index 0000000..4e19dff --- /dev/null +++ b/node_modules/@discordjs/ws/dist/defaultWorker.js @@ -0,0 +1,1051 @@ +"use strict"; +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __name = (target, value) => __defProp(target, "name", { value, configurable: true }); +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); + +// src/utils/WorkerBootstrapper.ts +var import_node_worker_threads3 = require("worker_threads"); +var import_collection7 = require("@discordjs/collection"); + +// src/strategies/context/WorkerContextFetchingStrategy.ts +var import_node_worker_threads2 = require("worker_threads"); +var import_collection2 = require("@discordjs/collection"); + +// src/strategies/sharding/WorkerShardingStrategy.ts +var import_node_events = require("events"); +var import_node_path = require("path"); +var import_node_worker_threads = require("worker_threads"); +var import_collection = require("@discordjs/collection"); + +// src/strategies/context/IContextFetchingStrategy.ts +async function managerToFetchingStrategyOptions(manager) { + const { + buildIdentifyThrottler, + buildStrategy, + retrieveSessionInfo, + updateSessionInfo, + shardCount, + shardIds, + rest, + ...managerOptions + } = manager.options; + return { + ...managerOptions, + gatewayInformation: await manager.fetchGatewayInformation(), + shardCount: await manager.getShardCount() + }; +} +__name(managerToFetchingStrategyOptions, "managerToFetchingStrategyOptions"); + +// src/strategies/context/WorkerContextFetchingStrategy.ts +var WorkerContextFetchingStrategy = class { + constructor(options) { + this.options = options; + if (import_node_worker_threads2.isMainThread) { + throw new Error("Cannot instantiate WorkerContextFetchingStrategy on the main thread"); + } + import_node_worker_threads2.parentPort.on("message", (payload) => { + if (payload.op === 3 /* SessionInfoResponse */) { + this.sessionPromises.get(payload.nonce)?.(payload.session); + this.sessionPromises.delete(payload.nonce); + } + if (payload.op === 4 /* ShardIdentifyResponse */) { + const promise = this.waitForIdentifyPromises.get(payload.nonce); + if (payload.ok) { + promise?.resolve(); + } else { + promise?.reject(promise.signal.reason); + } + this.waitForIdentifyPromises.delete(payload.nonce); + } + }); + } + static { + __name(this, "WorkerContextFetchingStrategy"); + } + sessionPromises = new import_collection2.Collection(); + waitForIdentifyPromises = new import_collection2.Collection(); + async retrieveSessionInfo(shardId) { + const nonce = Math.random(); + const payload = { + op: 3 /* RetrieveSessionInfo */, + shardId, + nonce + }; + const promise = new Promise((resolve2) => this.sessionPromises.set(nonce, resolve2)); + import_node_worker_threads2.parentPort.postMessage(payload); + return promise; + } + updateSessionInfo(shardId, sessionInfo) { + const payload = { + op: 4 /* UpdateSessionInfo */, + shardId, + session: sessionInfo + }; + import_node_worker_threads2.parentPort.postMessage(payload); + } + async waitForIdentify(shardId, signal) { + const nonce = Math.random(); + const payload = { + op: 5 /* WaitForIdentify */, + nonce, + shardId + }; + const promise = new Promise( + (resolve2, reject) => ( + // eslint-disable-next-line no-promise-executor-return + this.waitForIdentifyPromises.set(nonce, { signal, resolve: resolve2, reject }) + ) + ); + import_node_worker_threads2.parentPort.postMessage(payload); + const listener = /* @__PURE__ */ __name(() => { + const payload2 = { + op: 8 /* CancelIdentify */, + nonce + }; + import_node_worker_threads2.parentPort.postMessage(payload2); + }, "listener"); + signal.addEventListener("abort", listener); + try { + await promise; + } finally { + signal.removeEventListener("abort", listener); + } + } +}; + +// src/ws/WebSocketShard.ts +var import_node_buffer = require("buffer"); +var import_node_events2 = require("events"); +var import_node_timers = require("timers"); +var import_promises2 = require("timers/promises"); +var import_node_url = require("url"); +var import_node_util = require("util"); +var import_node_zlib = require("zlib"); +var import_collection6 = require("@discordjs/collection"); +var import_util2 = require("@discordjs/util"); +var import_async_queue2 = require("@sapphire/async-queue"); +var import_async_event_emitter = require("@vladfrangu/async_event_emitter"); +var import_v102 = require("discord-api-types/v10"); +var import_ws = require("ws"); + +// src/utils/constants.ts +var import_node_process = __toESM(require("process")); +var import_collection5 = require("@discordjs/collection"); +var import_util = require("@discordjs/util"); +var import_v10 = require("discord-api-types/v10"); + +// src/strategies/sharding/SimpleShardingStrategy.ts +var import_collection3 = require("@discordjs/collection"); + +// src/strategies/context/SimpleContextFetchingStrategy.ts +var SimpleContextFetchingStrategy = class _SimpleContextFetchingStrategy { + constructor(manager, options) { + this.manager = manager; + this.options = options; + } + static { + __name(this, "SimpleContextFetchingStrategy"); + } + // This strategy assumes every shard is running under the same process - therefore we need a single + // IdentifyThrottler per manager. + static throttlerCache = /* @__PURE__ */ new WeakMap(); + static async ensureThrottler(manager) { + const throttler = _SimpleContextFetchingStrategy.throttlerCache.get(manager); + if (throttler) { + return throttler; + } + const newThrottler = await manager.options.buildIdentifyThrottler(manager); + _SimpleContextFetchingStrategy.throttlerCache.set(manager, newThrottler); + return newThrottler; + } + async retrieveSessionInfo(shardId) { + return this.manager.options.retrieveSessionInfo(shardId); + } + updateSessionInfo(shardId, sessionInfo) { + return this.manager.options.updateSessionInfo(shardId, sessionInfo); + } + async waitForIdentify(shardId, signal) { + const throttler = await _SimpleContextFetchingStrategy.ensureThrottler(this.manager); + await throttler.waitForIdentify(shardId, signal); + } +}; + +// src/strategies/sharding/SimpleShardingStrategy.ts +var SimpleShardingStrategy = class { + static { + __name(this, "SimpleShardingStrategy"); + } + manager; + shards = new import_collection3.Collection(); + constructor(manager) { + this.manager = manager; + } + /** + * {@inheritDoc IShardingStrategy.spawn} + */ + async spawn(shardIds) { + const strategyOptions = await managerToFetchingStrategyOptions(this.manager); + for (const shardId of shardIds) { + const strategy = new SimpleContextFetchingStrategy(this.manager, strategyOptions); + const shard = new WebSocketShard(strategy, shardId); + for (const event of Object.values(WebSocketShardEvents)) { + shard.on(event, (payload) => this.manager.emit(event, { ...payload, shardId })); + } + this.shards.set(shardId, shard); + } + } + /** + * {@inheritDoc IShardingStrategy.connect} + */ + async connect() { + const promises = []; + for (const shard of this.shards.values()) { + promises.push(shard.connect()); + } + await Promise.all(promises); + } + /** + * {@inheritDoc IShardingStrategy.destroy} + */ + async destroy(options) { + const promises = []; + for (const shard of this.shards.values()) { + promises.push(shard.destroy(options)); + } + await Promise.all(promises); + this.shards.clear(); + } + /** + * {@inheritDoc IShardingStrategy.send} + */ + async send(shardId, payload) { + const shard = this.shards.get(shardId); + if (!shard) { + throw new RangeError(`Shard ${shardId} not found`); + } + return shard.send(payload); + } + /** + * {@inheritDoc IShardingStrategy.fetchStatus} + */ + async fetchStatus() { + return this.shards.mapValues((shard) => shard.status); + } +}; + +// src/throttling/SimpleIdentifyThrottler.ts +var import_promises = require("timers/promises"); +var import_collection4 = require("@discordjs/collection"); +var import_async_queue = require("@sapphire/async-queue"); +var SimpleIdentifyThrottler = class { + constructor(maxConcurrency) { + this.maxConcurrency = maxConcurrency; + } + static { + __name(this, "SimpleIdentifyThrottler"); + } + states = new import_collection4.Collection(); + /** + * {@inheritDoc IIdentifyThrottler.waitForIdentify} + */ + async waitForIdentify(shardId, signal) { + const key = shardId % this.maxConcurrency; + const state = this.states.ensure(key, () => { + return { + queue: new import_async_queue.AsyncQueue(), + resetsAt: Number.POSITIVE_INFINITY + }; + }); + await state.queue.wait({ signal }); + try { + const diff = state.resetsAt - Date.now(); + if (diff <= 5e3) { + const time = diff + Math.random() * 1500; + await (0, import_promises.setTimeout)(time); + } + state.resetsAt = Date.now() + 5e3; + } finally { + state.queue.shift(); + } + } +}; + +// src/utils/constants.ts +var DefaultDeviceProperty = `@discordjs/ws 1.0.1`; +var getDefaultSessionStore = (0, import_util.lazy)(() => new import_collection5.Collection()); +var DefaultWebSocketManagerOptions = { + async buildIdentifyThrottler(manager) { + 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, + identifyProperties: { + browser: DefaultDeviceProperty, + device: DefaultDeviceProperty, + os: import_node_process.default.platform + }, + version: import_v10.APIVersion, + encoding: "json" /* JSON */, + compression: null, + retrieveSessionInfo(shardId) { + const store = getDefaultSessionStore(); + return store.get(shardId) ?? null; + }, + updateSessionInfo(shardId, info) { + const store = getDefaultSessionStore(); + if (info) { + store.set(shardId, info); + } else { + store.delete(shardId); + } + }, + handshakeTimeout: 3e4, + helloTimeout: 6e4, + readyTimeout: 15e3 +}; +var ImportantGatewayOpcodes = /* @__PURE__ */ new Set([ + import_v10.GatewayOpcodes.Heartbeat, + import_v10.GatewayOpcodes.Identify, + import_v10.GatewayOpcodes.Resume +]); +function getInitialSendRateLimitState() { + return { + remaining: 120, + resetAt: Date.now() + 6e4 + }; +} +__name(getInitialSendRateLimitState, "getInitialSendRateLimitState"); + +// src/ws/WebSocketShard.ts +var getZlibSync = (0, import_util2.lazy)(async () => import("zlib-sync").then((mod) => mod.default).catch(() => null)); +var WebSocketShardEvents = /* @__PURE__ */ ((WebSocketShardEvents2) => { + WebSocketShardEvents2["Closed"] = "closed"; + WebSocketShardEvents2["Debug"] = "debug"; + WebSocketShardEvents2["Dispatch"] = "dispatch"; + WebSocketShardEvents2["Error"] = "error"; + WebSocketShardEvents2["HeartbeatComplete"] = "heartbeat"; + WebSocketShardEvents2["Hello"] = "hello"; + WebSocketShardEvents2["Ready"] = "ready"; + WebSocketShardEvents2["Resumed"] = "resumed"; + return WebSocketShardEvents2; +})(WebSocketShardEvents || {}); +var WebSocketShardDestroyRecovery = /* @__PURE__ */ ((WebSocketShardDestroyRecovery2) => { + WebSocketShardDestroyRecovery2[WebSocketShardDestroyRecovery2["Reconnect"] = 0] = "Reconnect"; + WebSocketShardDestroyRecovery2[WebSocketShardDestroyRecovery2["Resume"] = 1] = "Resume"; + return WebSocketShardDestroyRecovery2; +})(WebSocketShardDestroyRecovery || {}); +var WebSocketConstructor = import_ws.WebSocket; +var WebSocketShard = class extends import_async_event_emitter.AsyncEventEmitter { + static { + __name(this, "WebSocketShard"); + } + connection = null; + useIdentifyCompress = false; + inflate = null; + textDecoder = new import_node_util.TextDecoder(); + replayedEvents = 0; + isAck = true; + sendRateLimitState = getInitialSendRateLimitState(); + initialHeartbeatTimeoutController = null; + heartbeatInterval = null; + lastHeartbeatAt = -1; + // Indicates whether the shard has already resolved its original connect() call + initialConnectResolved = false; + // Indicates if we failed to connect to the ws url (ECONNREFUSED/ECONNRESET) + failedToConnectDueToNetworkError = false; + sendQueue = new import_async_queue2.AsyncQueue(); + timeoutAbortControllers = new import_collection6.Collection(); + strategy; + id; + #status = 0 /* Idle */; + get status() { + return this.#status; + } + constructor(strategy, id) { + super(); + this.strategy = strategy; + this.id = id; + } + async connect() { + const controller = new AbortController(); + let promise; + if (!this.initialConnectResolved) { + promise = Promise.race([ + (0, import_node_events2.once)(this, "ready" /* Ready */, { signal: controller.signal }), + (0, import_node_events2.once)(this, "resumed" /* Resumed */, { signal: controller.signal }) + ]); + } + void this.internalConnect(); + try { + await promise; + } catch ({ error }) { + throw error; + } finally { + controller.abort(); + } + this.initialConnectResolved = true; + } + async internalConnect() { + if (this.#status !== 0 /* Idle */) { + throw new Error("Tried to connect a shard that wasn't idle"); + } + const { version, encoding, compression } = this.strategy.options; + const params = new import_node_url.URLSearchParams({ v: version, encoding }); + if (compression) { + const zlib = await getZlibSync(); + if (zlib) { + params.append("compress", compression); + this.inflate = new zlib.Inflate({ + chunkSize: 65535, + to: "string" + }); + } else if (!this.useIdentifyCompress) { + this.useIdentifyCompress = true; + console.warn( + "WebSocketShard: Compression is enabled but zlib-sync is not installed, falling back to identify compress" + ); + } + } + const session = await this.strategy.retrieveSessionInfo(this.id); + const url = `${session?.resumeURL ?? this.strategy.options.gatewayInformation.url}?${params.toString()}`; + this.debug([`Connecting to ${url}`]); + const connection = new WebSocketConstructor(url, { + handshakeTimeout: this.strategy.options.handshakeTimeout ?? void 0 + }); + connection.binaryType = "arraybuffer"; + connection.onmessage = (event) => { + void this.onMessage(event.data, event.data instanceof ArrayBuffer); + }; + connection.onerror = (event) => { + this.onError(event.error); + }; + connection.onclose = (event) => { + void this.onClose(event.code); + }; + this.connection = connection; + this.#status = 1 /* Connecting */; + this.sendRateLimitState = getInitialSendRateLimitState(); + const { ok } = await this.waitForEvent("hello" /* Hello */, this.strategy.options.helloTimeout); + if (!ok) { + return; + } + if (session?.shardCount === this.strategy.options.shardCount) { + await this.resume(session); + } else { + await this.identify(); + } + } + async destroy(options = {}) { + if (this.#status === 0 /* Idle */) { + this.debug(["Tried to destroy a shard that was idle"]); + return; + } + if (!options.code) { + options.code = options.recover === 1 /* Resume */ ? 4200 /* Resuming */ : 1e3 /* Normal */; + } + this.debug([ + "Destroying shard", + `Reason: ${options.reason ?? "none"}`, + `Code: ${options.code}`, + `Recover: ${options.recover === void 0 ? "none" : WebSocketShardDestroyRecovery[options.recover]}` + ]); + this.isAck = true; + if (this.heartbeatInterval) { + (0, import_node_timers.clearInterval)(this.heartbeatInterval); + } + if (this.initialHeartbeatTimeoutController) { + this.initialHeartbeatTimeoutController.abort(); + this.initialHeartbeatTimeoutController = null; + } + this.lastHeartbeatAt = -1; + for (const controller of this.timeoutAbortControllers.values()) { + controller.abort(); + } + this.timeoutAbortControllers.clear(); + this.failedToConnectDueToNetworkError = false; + if (options.recover !== 1 /* Resume */) { + await this.strategy.updateSessionInfo(this.id, null); + } + if (this.connection) { + this.connection.onmessage = null; + this.connection.onclose = null; + const shouldClose = this.connection.readyState === import_ws.WebSocket.OPEN; + this.debug([ + "Connection status during destroy", + `Needs closing: ${shouldClose}`, + `Ready state: ${this.connection.readyState}` + ]); + if (shouldClose) { + let outerResolve; + const promise = new Promise((resolve2) => { + outerResolve = resolve2; + }); + this.connection.onclose = outerResolve; + this.connection.close(options.code, options.reason); + await promise; + this.emit("closed" /* Closed */, { code: options.code }); + } + this.connection.onerror = null; + } else { + this.debug(["Destroying a shard that has no connection; please open an issue on GitHub"]); + } + this.#status = 0 /* Idle */; + if (options.recover !== void 0) { + await (0, import_promises2.setTimeout)(500); + return this.internalConnect(); + } + } + async waitForEvent(event, timeoutDuration) { + this.debug([`Waiting for event ${event} ${timeoutDuration ? `for ${timeoutDuration}ms` : "indefinitely"}`]); + const timeoutController = new AbortController(); + const timeout = timeoutDuration ? (0, import_node_timers.setTimeout)(() => timeoutController.abort(), timeoutDuration).unref() : null; + this.timeoutAbortControllers.set(event, timeoutController); + const closeController = new AbortController(); + try { + const closed = await Promise.race([ + (0, import_node_events2.once)(this, event, { signal: timeoutController.signal }).then(() => false), + (0, import_node_events2.once)(this, "closed" /* Closed */, { signal: closeController.signal }).then(() => true) + ]); + return { ok: !closed }; + } catch { + void this.destroy({ + code: 1e3 /* Normal */, + reason: "Something timed out or went wrong while waiting for an event", + recover: 0 /* Reconnect */ + }); + return { ok: false }; + } finally { + if (timeout) { + (0, import_node_timers.clearTimeout)(timeout); + } + this.timeoutAbortControllers.delete(event); + if (!closeController.signal.aborted) { + closeController.abort(); + } + } + } + async send(payload) { + if (!this.connection) { + throw new Error("WebSocketShard wasn't connected"); + } + if (this.#status !== 3 /* Ready */ && !ImportantGatewayOpcodes.has(payload.op)) { + this.debug(["Tried to send a non-crucial payload before the shard was ready, waiting"]); + try { + await (0, import_node_events2.once)(this, "ready" /* Ready */); + } catch { + return this.send(payload); + } + } + await this.sendQueue.wait(); + if (--this.sendRateLimitState.remaining <= 0) { + const now = Date.now(); + if (this.sendRateLimitState.resetAt > now) { + const sleepFor = this.sendRateLimitState.resetAt - now; + this.debug([`Was about to hit the send rate limit, sleeping for ${sleepFor}ms`]); + const controller = new AbortController(); + const interrupted = await Promise.race([ + (0, import_promises2.setTimeout)(sleepFor).then(() => false), + (0, import_node_events2.once)(this, "closed" /* Closed */, { signal: controller.signal }).then(() => true) + ]); + if (interrupted) { + this.debug(["Connection closed while waiting for the send rate limit to reset, re-queueing payload"]); + this.sendQueue.shift(); + return this.send(payload); + } + controller.abort(); + } + this.sendRateLimitState = getInitialSendRateLimitState(); + } + this.sendQueue.shift(); + this.connection.send(JSON.stringify(payload)); + } + async identify() { + this.debug(["Waiting for identify throttle"]); + const controller = new AbortController(); + const closeHandler = /* @__PURE__ */ __name(() => { + controller.abort(); + }, "closeHandler"); + this.on("closed" /* Closed */, closeHandler); + try { + await this.strategy.waitForIdentify(this.id, controller.signal); + } catch { + if (controller.signal.aborted) { + this.debug(["Was waiting for an identify, but the shard closed in the meantime"]); + return; + } + this.debug([ + "IContextFetchingStrategy#waitForIdentify threw an unknown error.", + "If you're using a custom strategy, this is probably nothing to worry about.", + "If you're not, please open an issue on GitHub." + ]); + await this.destroy({ + reason: "Identify throttling logic failed", + recover: 1 /* Resume */ + }); + } finally { + this.off("closed" /* Closed */, closeHandler); + } + this.debug([ + "Identifying", + `shard id: ${this.id.toString()}`, + `shard count: ${this.strategy.options.shardCount}`, + `intents: ${this.strategy.options.intents}`, + `compression: ${this.inflate ? "zlib-stream" : this.useIdentifyCompress ? "identify" : "none"}` + ]); + const d = { + token: this.strategy.options.token, + properties: this.strategy.options.identifyProperties, + intents: this.strategy.options.intents, + compress: this.useIdentifyCompress, + shard: [this.id, this.strategy.options.shardCount] + }; + if (this.strategy.options.largeThreshold) { + d.large_threshold = this.strategy.options.largeThreshold; + } + if (this.strategy.options.initialPresence) { + d.presence = this.strategy.options.initialPresence; + } + await this.send({ + op: import_v102.GatewayOpcodes.Identify, + d + }); + await this.waitForEvent("ready" /* Ready */, this.strategy.options.readyTimeout); + } + async resume(session) { + this.debug([ + "Resuming session", + `resume url: ${session.resumeURL}`, + `sequence: ${session.sequence}`, + `shard id: ${this.id.toString()}` + ]); + this.#status = 2 /* Resuming */; + this.replayedEvents = 0; + return this.send({ + op: import_v102.GatewayOpcodes.Resume, + d: { + token: this.strategy.options.token, + seq: session.sequence, + session_id: session.sessionId + } + }); + } + async heartbeat(requested = false) { + if (!this.isAck && !requested) { + return this.destroy({ reason: "Zombie connection", recover: 1 /* Resume */ }); + } + const session = await this.strategy.retrieveSessionInfo(this.id); + await this.send({ + op: import_v102.GatewayOpcodes.Heartbeat, + d: session?.sequence ?? null + }); + this.lastHeartbeatAt = Date.now(); + this.isAck = false; + } + async unpackMessage(data, isBinary) { + if (!isBinary) { + try { + return JSON.parse(data); + } catch { + return null; + } + } + const decompressable = new Uint8Array(data); + if (this.useIdentifyCompress) { + return new Promise((resolve2, reject) => { + (0, import_node_zlib.inflate)(decompressable, { chunkSize: 65535 }, (err, result) => { + if (err) { + reject(err); + return; + } + resolve2(JSON.parse(this.textDecoder.decode(result))); + }); + }); + } + if (this.inflate) { + const l = decompressable.length; + const flush = l >= 4 && decompressable[l - 4] === 0 && decompressable[l - 3] === 0 && decompressable[l - 2] === 255 && decompressable[l - 1] === 255; + const zlib = await getZlibSync(); + this.inflate.push(import_node_buffer.Buffer.from(decompressable), flush ? zlib.Z_SYNC_FLUSH : zlib.Z_NO_FLUSH); + if (this.inflate.err) { + this.emit("error" /* Error */, { + error: new Error(`${this.inflate.err}${this.inflate.msg ? `: ${this.inflate.msg}` : ""}`) + }); + } + if (!flush) { + return null; + } + const { result } = this.inflate; + if (!result) { + return null; + } + return JSON.parse(typeof result === "string" ? result : this.textDecoder.decode(result)); + } + this.debug([ + "Received a message we were unable to decompress", + `isBinary: ${isBinary.toString()}`, + `useIdentifyCompress: ${this.useIdentifyCompress.toString()}`, + `inflate: ${Boolean(this.inflate).toString()}` + ]); + return null; + } + async onMessage(data, isBinary) { + const payload = await this.unpackMessage(data, isBinary); + if (!payload) { + return; + } + switch (payload.op) { + case import_v102.GatewayOpcodes.Dispatch: { + if (this.#status === 2 /* Resuming */) { + this.replayedEvents++; + } + switch (payload.t) { + case import_v102.GatewayDispatchEvents.Ready: { + this.#status = 3 /* Ready */; + const session2 = { + sequence: payload.s, + sessionId: payload.d.session_id, + shardId: this.id, + shardCount: this.strategy.options.shardCount, + resumeURL: payload.d.resume_gateway_url + }; + await this.strategy.updateSessionInfo(this.id, session2); + this.emit("ready" /* Ready */, { data: payload.d }); + break; + } + case import_v102.GatewayDispatchEvents.Resumed: { + this.#status = 3 /* Ready */; + this.debug([`Resumed and replayed ${this.replayedEvents} events`]); + this.emit("resumed" /* Resumed */); + break; + } + default: { + break; + } + } + const session = await this.strategy.retrieveSessionInfo(this.id); + if (session) { + if (payload.s > session.sequence) { + await this.strategy.updateSessionInfo(this.id, { ...session, sequence: payload.s }); + } + } else { + this.debug([ + `Received a ${payload.t} event but no session is available. Session information cannot be re-constructed in this state without a full reconnect` + ]); + } + this.emit("dispatch" /* Dispatch */, { data: payload }); + break; + } + case import_v102.GatewayOpcodes.Heartbeat: { + await this.heartbeat(true); + break; + } + case import_v102.GatewayOpcodes.Reconnect: { + await this.destroy({ + reason: "Told to reconnect by Discord", + recover: 1 /* Resume */ + }); + break; + } + case import_v102.GatewayOpcodes.InvalidSession: { + this.debug([`Invalid session; will attempt to resume: ${payload.d.toString()}`]); + const session = await this.strategy.retrieveSessionInfo(this.id); + if (payload.d && session) { + await this.resume(session); + } else { + await this.destroy({ + reason: "Invalid session", + recover: 0 /* Reconnect */ + }); + } + break; + } + case import_v102.GatewayOpcodes.Hello: { + this.emit("hello" /* Hello */); + const jitter = Math.random(); + const firstWait = Math.floor(payload.d.heartbeat_interval * jitter); + this.debug([`Preparing first heartbeat of the connection with a jitter of ${jitter}; waiting ${firstWait}ms`]); + try { + const controller = new AbortController(); + this.initialHeartbeatTimeoutController = controller; + await (0, import_promises2.setTimeout)(firstWait, void 0, { signal: controller.signal }); + } catch { + this.debug(["Cancelled initial heartbeat due to #destroy being called"]); + return; + } finally { + this.initialHeartbeatTimeoutController = null; + } + await this.heartbeat(); + this.debug([`First heartbeat sent, starting to beat every ${payload.d.heartbeat_interval}ms`]); + this.heartbeatInterval = (0, import_node_timers.setInterval)(() => void this.heartbeat(), payload.d.heartbeat_interval); + break; + } + case import_v102.GatewayOpcodes.HeartbeatAck: { + this.isAck = true; + const ackAt = Date.now(); + this.emit("heartbeat" /* HeartbeatComplete */, { + ackAt, + heartbeatAt: this.lastHeartbeatAt, + latency: ackAt - this.lastHeartbeatAt + }); + break; + } + } + } + onError(error) { + if ("code" in error && ["ECONNRESET", "ECONNREFUSED"].includes(error.code)) { + this.debug(["Failed to connect to the gateway URL specified due to a network error"]); + this.failedToConnectDueToNetworkError = true; + return; + } + this.emit("error" /* Error */, { error }); + } + async onClose(code) { + this.emit("closed" /* Closed */, { code }); + switch (code) { + case 1e3 /* Normal */: { + return this.destroy({ + code, + reason: "Got disconnected by Discord", + recover: 0 /* Reconnect */ + }); + } + case 4200 /* Resuming */: { + break; + } + case import_v102.GatewayCloseCodes.UnknownError: { + this.debug([`An unknown error occurred: ${code}`]); + return this.destroy({ code, recover: 1 /* Resume */ }); + } + case import_v102.GatewayCloseCodes.UnknownOpcode: { + this.debug(["An invalid opcode was sent to Discord."]); + return this.destroy({ code, recover: 1 /* Resume */ }); + } + case import_v102.GatewayCloseCodes.DecodeError: { + this.debug(["An invalid payload was sent to Discord."]); + return this.destroy({ code, recover: 1 /* Resume */ }); + } + case import_v102.GatewayCloseCodes.NotAuthenticated: { + this.debug(["A request was somehow sent before the identify/resume payload."]); + return this.destroy({ code, recover: 0 /* Reconnect */ }); + } + case import_v102.GatewayCloseCodes.AuthenticationFailed: { + this.emit("error" /* Error */, { + error: new Error("Authentication failed") + }); + return this.destroy({ code }); + } + case import_v102.GatewayCloseCodes.AlreadyAuthenticated: { + this.debug(["More than one auth payload was sent."]); + return this.destroy({ code, recover: 0 /* Reconnect */ }); + } + case import_v102.GatewayCloseCodes.InvalidSeq: { + this.debug(["An invalid sequence was sent."]); + return this.destroy({ code, recover: 0 /* Reconnect */ }); + } + case import_v102.GatewayCloseCodes.RateLimited: { + this.debug(["The WebSocket rate limit has been hit, this should never happen"]); + return this.destroy({ code, recover: 0 /* Reconnect */ }); + } + case import_v102.GatewayCloseCodes.SessionTimedOut: { + this.debug(["Session timed out."]); + return this.destroy({ code, recover: 1 /* Resume */ }); + } + case import_v102.GatewayCloseCodes.InvalidShard: { + this.emit("error" /* Error */, { + error: new Error("Invalid shard") + }); + return this.destroy({ code }); + } + case import_v102.GatewayCloseCodes.ShardingRequired: { + this.emit("error" /* Error */, { + error: new Error("Sharding is required") + }); + return this.destroy({ code }); + } + case import_v102.GatewayCloseCodes.InvalidAPIVersion: { + this.emit("error" /* Error */, { + error: new Error("Used an invalid API version") + }); + return this.destroy({ code }); + } + case import_v102.GatewayCloseCodes.InvalidIntents: { + this.emit("error" /* Error */, { + error: new Error("Used invalid intents") + }); + return this.destroy({ code }); + } + case import_v102.GatewayCloseCodes.DisallowedIntents: { + this.emit("error" /* Error */, { + error: new Error("Used disallowed intents") + }); + return this.destroy({ code }); + } + default: { + this.debug([ + `The gateway closed with an unexpected code ${code}, attempting to ${this.failedToConnectDueToNetworkError ? "reconnect" : "resume"}.` + ]); + return this.destroy({ + code, + recover: this.failedToConnectDueToNetworkError ? 0 /* Reconnect */ : 1 /* Resume */ + }); + } + } + } + debug(messages) { + const message = `${messages[0]}${messages.length > 1 ? ` +${messages.slice(1).map((m) => ` ${m}`).join("\n")}` : ""}`; + this.emit("debug" /* Debug */, { message }); + } +}; + +// src/utils/WorkerBootstrapper.ts +var WorkerBootstrapper = class { + static { + __name(this, "WorkerBootstrapper"); + } + /** + * The data passed to the worker thread + */ + data = import_node_worker_threads3.workerData; + /** + * The shards that are managed by this worker + */ + shards = new import_collection7.Collection(); + constructor() { + if (import_node_worker_threads3.isMainThread) { + throw new Error("Expected WorkerBootstrap to not be used within the main thread"); + } + } + /** + * Helper method to initiate a shard's connection process + */ + async connect(shardId) { + const shard = this.shards.get(shardId); + if (!shard) { + throw new RangeError(`Shard ${shardId} does not exist`); + } + await shard.connect(); + } + /** + * Helper method to destroy a shard + */ + async destroy(shardId, options) { + const shard = this.shards.get(shardId); + if (!shard) { + throw new RangeError(`Shard ${shardId} does not exist`); + } + await shard.destroy(options); + } + /** + * Helper method to attach event listeners to the parentPort + */ + setupThreadEvents() { + import_node_worker_threads3.parentPort.on("messageerror", (err) => { + throw err; + }).on("message", async (payload) => { + switch (payload.op) { + case 0 /* Connect */: { + await this.connect(payload.shardId); + const response = { + op: 0 /* Connected */, + shardId: payload.shardId + }; + import_node_worker_threads3.parentPort.postMessage(response); + break; + } + case 1 /* Destroy */: { + await this.destroy(payload.shardId, payload.options); + const response = { + op: 1 /* Destroyed */, + shardId: payload.shardId + }; + import_node_worker_threads3.parentPort.postMessage(response); + break; + } + case 2 /* Send */: { + const shard = this.shards.get(payload.shardId); + if (!shard) { + throw new RangeError(`Shard ${payload.shardId} does not exist`); + } + await shard.send(payload.payload); + break; + } + case 3 /* SessionInfoResponse */: { + break; + } + case 4 /* ShardIdentifyResponse */: { + break; + } + case 5 /* FetchStatus */: { + const shard = this.shards.get(payload.shardId); + if (!shard) { + throw new Error(`Shard ${payload.shardId} does not exist`); + } + const response = { + op: 6 /* FetchStatusResponse */, + status: shard.status, + nonce: payload.nonce + }; + import_node_worker_threads3.parentPort.postMessage(response); + break; + } + } + }); + } + /** + * Bootstraps the worker thread with the provided options + */ + async bootstrap(options = {}) { + for (const shardId of this.data.shardIds) { + const shard = new WebSocketShard(new WorkerContextFetchingStrategy(this.data), shardId); + for (const event of options.forwardEvents ?? Object.values(WebSocketShardEvents)) { + shard.on(event, (data) => { + const payload = { + op: 2 /* Event */, + event, + data, + shardId + }; + import_node_worker_threads3.parentPort.postMessage(payload); + }); + } + await options.shardCallback?.(shard); + this.shards.set(shardId, shard); + } + this.setupThreadEvents(); + const message = { + op: 7 /* WorkerReady */ + }; + import_node_worker_threads3.parentPort.postMessage(message); + } +}; + +// src/strategies/sharding/defaultWorker.ts +var bootstrapper = new WorkerBootstrapper(); +void bootstrapper.bootstrap(); +//# sourceMappingURL=defaultWorker.js.map
\ No newline at end of file |