bakit 2.2.4 → 3.0.0

package/dist/index.cjs

@@ -0,0 +1,672 @@
+'use strict';
+
+var gateway = require('@bakit/gateway');
+var rest = require('@bakit/rest');
+var service = require('@bakit/service');
+var utils = require('@bakit/utils');
+var EventEmitter = require('events');
+var collection = require('@discordjs/collection');
+var v10 = require('discord-api-types/v10');
+var tinyMixin = require('tiny-mixin');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var EventEmitter__default = /*#__PURE__*/_interopDefault(EventEmitter);
+var v10__namespace = /*#__PURE__*/_interopNamespace(v10);
+
+// src/modules/gateway.ts
+
+// src/lib/structures/BaseStructure.ts
+var BaseStructure = class {
+  constructor(client) {
+    Object.defineProperty(this, "client", {
+      value: client,
+      enumerable: false,
+      writable: false
+    });
+  }
+  toJSON() {
+    return {};
+  }
+};
+var User = class extends BaseStructure {
+  constructor(client, data) {
+    super(client);
+    this.data = data;
+  }
+  get id() {
+    return this.data.id;
+  }
+  get username() {
+    return this.data.username;
+  }
+  get discriminator() {
+    return this.data.discriminator;
+  }
+  get globalName() {
+    return this.data.global_name;
+  }
+  get tag() {
+    return this.discriminator !== "0" && this.discriminator !== "0000" ? `${this.username}#${this.discriminator}` : this.username;
+  }
+  get displayName() {
+    return this.globalName ?? this.tag;
+  }
+  get avatar() {
+    return this.data.avatar ?? void 0;
+  }
+  get bot() {
+    return !!this.data.bot;
+  }
+  get system() {
+    return !!this.data.system;
+  }
+  get mfaEnabled() {
+    return this.data.mfa_enabled;
+  }
+  get locale() {
+    return this.data.locale;
+  }
+  get verified() {
+    return this.data.verified;
+  }
+  get email() {
+    return this.data.email;
+  }
+  get flags() {
+    return this.data.flags;
+  }
+  get premiumType() {
+    return this.data.premium_type;
+  }
+  get publicFlags() {
+    return this.data.public_flags;
+  }
+  get banner() {
+    return this.data.banner;
+  }
+  get accentColor() {
+    return this.data.accent_color ?? void 0;
+  }
+  get createdAt() {
+    return utils.getSnowflakeDate(this.id);
+  }
+  get createdTimestamp() {
+    return this.createdAt.getTime();
+  }
+  get hexAccentColor() {
+    return this.accentColor !== void 0 ? `#${this.accentColor.toString(16).padStart(6, "0")}` : void 0;
+  }
+  get defaultAvatarURL() {
+    return `https://cdn.discordapp.com/embed/avatars/${this.discriminator !== "0" && this.discriminator !== "0000" ? BigInt(this.discriminator) % 5n : (BigInt(this.id) >> 22n) % 6n}.png`;
+  }
+  getAvatarURL(options) {
+    if (!this.avatar)
+      return;
+    let isAnimated = this.avatar.startsWith("a_"), ext = options?.extension ?? (isAnimated ? "gif" : "png"), size = options?.size ? `?size=${options.size}` : "";
+    return `https://cdn.discordapp.com/avatars/${this.id}/${this.avatar}.${ext}${size}`;
+  }
+  getDisplayAvatarURL(options) {
+    return this.getAvatarURL(options) ?? this.defaultAvatarURL;
+  }
+  equals(other) {
+    return typeof other == "string" ? other === this.id : other.id === this.id && other.username === this.username && other.discriminator === this.discriminator && other.bot === this.bot && other.createdTimestamp === this.createdTimestamp;
+  }
+  toJSON() {
+    return this.data;
+  }
+  toString() {
+    return `<@${this.id}>`;
+  }
+};
+
+// src/lib/structures/Message.ts
+var Message = class extends BaseStructure {
+  constructor(client, data) {
+    super(client);
+    this.data = data;
+  }
+  cachedAuthor;
+  get partial() {
+    return typeof this.data.content != "string" || typeof this.data.author != "object";
+  }
+  get content() {
+    return this.data.content;
+  }
+  get id() {
+    return this.data.id;
+  }
+  get channelId() {
+    return this.data.channel_id;
+  }
+  get channel() {
+    return this.guild.channels.get(this.channelId);
+  }
+  get guildId() {
+    return "guild_id" in this.data ? this.data.guild_id : void 0;
+  }
+  get guild() {
+    return this.guildId ? this.client.guilds.get(this.guildId) : void 0;
+  }
+  get author() {
+    return this.cachedAuthor ??= new User(this.client, this.data.author), this.cachedAuthor;
+  }
+  get createdAt() {
+    return new Date(this.data.timestamp);
+  }
+  get editedAt() {
+    return this.data.edited_timestamp ? new Date(this.data.edited_timestamp) : void 0;
+  }
+  get createdTimestamp() {
+    return this.createdAt.getTime();
+  }
+  get editedTimestamp() {
+    return this.editedAt?.getTime();
+  }
+  get url() {
+    return `https://discord.com/channels/${this.guildId ?? "@me"}/${this.channelId}/${this.id}`;
+  }
+  async fetch() {
+    let message = await this.client.helper.fetchMessage(this.channelId, this.id);
+    return this.data = message.data, this.cachedAuthor = message.cachedAuthor, this;
+  }
+  async reply(options) {
+    return this.client.helper.replyMessage(this.channelId, this.id, options);
+  }
+  async sendToChannel(options) {
+    return this.client.helper.createMessage(this.channelId, options);
+  }
+  toJSON() {
+    return this.data;
+  }
+  toString() {
+    return this.data.content;
+  }
+};
+
+// src/lib/structures/channel/BaseChannel.ts
+var BaseChannel = class extends BaseStructure {
+  constructor(client, data) {
+    super(client);
+    this.data = data;
+  }
+  get id() {
+    return this.data.id;
+  }
+  get type() {
+    return this.data.type;
+  }
+  toString() {
+    return `<#${this.id}>`;
+  }
+  toJSON() {
+    return this.data;
+  }
+  isTextBased() {
+    return "send" in this;
+  }
+  isVoiceBased() {
+    return "join" in this;
+  }
+  inGuild() {
+    return "guild_id" in this.data;
+  }
+  _patch(data) {
+    this.data = { ...this.data, ...data };
+  }
+};
+var TextBasedChannelMixin = tinyMixin.createMixin((base) => {
+  class TextBasedChannel extends base {
+    send(options) {
+      return this.client.helper.createMessage(this.id, options);
+    }
+  }
+  return TextBasedChannel;
+}), VoiceBasedChannelMixin = tinyMixin.createMixin((base) => {
+  class VoiceBasedChannel extends base {
+  }
+  return VoiceBasedChannel;
+}), GuildChannelMixin = tinyMixin.createMixin((base) => {
+  class GuildChannel extends base {
+    get guildId() {
+      if (!this.data.guild_id)
+        throw new Error("This channel is not a guild channel");
+      return this.data.guild_id;
+    }
+    get guild() {
+      return this.client.guilds.get(this.guildId);
+    }
+  }
+  return GuildChannel;
+});
+var GuildTextChannel = class extends tinyMixin.applyMixins(BaseChannel, [
+  GuildChannelMixin,
+  TextBasedChannelMixin
+]) {
+};
+var GuildVoiceChannel = class extends tinyMixin.applyMixins(BaseChannel, [
+  GuildChannelMixin,
+  TextBasedChannelMixin,
+  VoiceBasedChannelMixin
+]) {
+};
+function createChannel(client, data) {
+  switch (data.type) {
+    case v10.ChannelType.GuildText:
+      return new GuildTextChannel(client, data);
+    case v10.ChannelType.GuildVoice:
+      return new GuildVoiceChannel(client, data);
+    default:
+      return null;
+  }
+}
+
+// src/lib/structures/Guild.ts
+var Guild = class extends BaseStructure {
+  constructor(client, data) {
+    super(client);
+    this.data = data;
+  }
+  cachedChannels;
+  get id() {
+    return this.data.id;
+  }
+  get name() {
+    return this.data.name;
+  }
+  get icon() {
+    return this.data.icon;
+  }
+  get banner() {
+    return this.data.banner;
+  }
+  get owner() {
+    return this.data.owner_id;
+  }
+  get mfaLevel() {
+    return this.data.mfa_level;
+  }
+  get verificationLevel() {
+    return this.data.verification_level;
+  }
+  get channels() {
+    if (!this.cachedChannels && (this.cachedChannels = new collection.Collection(), "channels" in this.data))
+      for (let data of this.data.channels) {
+        let channel = createChannel(this.client, data);
+        channel && this.cachedChannels.set(channel.id, channel);
+      }
+    return this.cachedChannels;
+  }
+  _patch(data) {
+    this.data = { ...this.data, ...data };
+  }
+  // public get roles() {
+  // 	return this.data.roles;
+  // }
+};
+var ClientHelper = class _ClientHelper {
+  constructor(client) {
+    Object.defineProperty(this, "client", {
+      value: client,
+      enumerable: false,
+      writable: false
+    });
+  }
+  async fetchMessage(channelId, messageId) {
+    let data = await this.client.rest.get(v10.Routes.channelMessage(channelId, messageId));
+    return new Message(this.client, data);
+  }
+  async deleteMessage(channelId, messageId) {
+    return this.client.rest.delete(v10.Routes.channelMessage(channelId, messageId));
+  }
+  async createMessage(channelId, options) {
+    return this.client.rest.post(v10.Routes.channelMessages(channelId), {
+      body: _ClientHelper.toAPICreateMessagePayload(options)
+    });
+  }
+  async replyMessage(channelId, messageId, options) {
+    return this.createMessage(channelId, {
+      ...options,
+      messageReference: {
+        channel_id: channelId,
+        message_id: messageId
+      }
+    });
+  }
+  async fetchGuild(guildId) {
+    let data = await this.client.rest.get(v10.Routes.guild(guildId));
+    return new Guild(this.client, data);
+  }
+  static toAPICreateMessagePayload(options) {
+    return {
+      content: options.content,
+      tts: options.tts,
+      embeds: options.embeds,
+      allowed_mentions: options.allowedMentions,
+      message_reference: options.messageReference,
+      flags: options.flags
+    };
+  }
+};
+
+// src/lib/client/Partial.ts
+var Partial = /* @__PURE__ */ ((Partial2) => (Partial2[Partial2.Message = 0] = "Message", Partial2[Partial2.User = 1] = "User", Partial2))(Partial || {});
+var IntentsBitField = class _IntentsBitField {
+  value;
+  constructor(input) {
+    this.value = _IntentsBitField.resolve(input);
+  }
+  static resolve(input) {
+    return Array.isArray(input) ? input.reduce((acc, intent) => acc | BigInt(intent), 0n) : BigInt(input);
+  }
+  has(intent) {
+    return (this.value & BigInt(intent)) !== 0n;
+  }
+  toBigInt() {
+    return this.value;
+  }
+  toNumber() {
+    return Number(this.value);
+  }
+  toJSON() {
+    return this.value.toString();
+  }
+  toString() {
+    return this.value.toString();
+  }
+};
+
+// src/lib/client/Client.ts
+var Client = class extends EventEmitter__default.default {
+  options;
+  shards;
+  rest;
+  helper;
+  guilds = new collection.Collection();
+  #user;
+  #ready = false;
+  constructor(options, rest$1) {
+    super();
+    let intents = options.intents instanceof IntentsBitField ? options.intents : new IntentsBitField(options.intents), sharding = {
+      shardsPerCluster: options.sharding?.shardsPerCluster ?? 1,
+      totalShards: options.sharding?.totalShards ?? 1
+    };
+    this.options = {
+      token: options.token,
+      intents,
+      sharding,
+      partials: new Set(options.partials ?? [])
+    }, this.rest = rest$1 ?? new rest.REST({ token: options.token }), this.shards = new gateway.ShardingManager(
+      {
+        ...this.options.sharding,
+        token: this.options.token,
+        intents: this.options.intents.toBigInt()
+      },
+      rest$1
+    ), this.helper = new ClientHelper(this), this.#setupShardsListeners();
+  }
+  get user() {
+    return this.#user;
+  }
+  async login() {
+    if (this.#user || this.shards.ready || this.shards.clusters.size > 0)
+      throw new Error("Cannot login twice");
+    return await this.shards.spawn(), new Promise((resolve, reject) => {
+      let cleanup = () => {
+        this.removeListener("ready", onReady), this.removeListener("error", onError);
+      }, onReady = () => {
+        cleanup(), resolve();
+      }, onError = (error) => {
+        cleanup(), reject(error);
+      };
+      this.once("ready", onReady), this.once("error", onError);
+    });
+  }
+  #setupShardsListeners() {
+    this.shards.on("dispatch", (_, shardId, payload) => this.#handleDispatch(shardId, payload)), this.shards.on("raw", (_, shardId, payload) => this.emit("raw", shardId, payload)), this.shards.once("ready", () => this.#tryEmitReady());
+  }
+  async #handleDispatch(shardId, payload) {
+    switch (this.emit("dispatch", shardId, payload), payload.t) {
+      case v10.GatewayDispatchEvents.Ready: {
+        this.#user ??= new User(this, payload.d.user), this.#tryEmitReady();
+        break;
+      }
+      case v10.GatewayDispatchEvents.MessageCreate: {
+        let message = new Message(this, payload.d);
+        if (message.partial && !this.options.partials.has(0 /* Message */))
+          return;
+        this.emit("messageCreate", message);
+        break;
+      }
+      case v10.GatewayDispatchEvents.MessageUpdate: {
+        let message = new Message(this, payload.d);
+        if (message.partial && !this.options.partials.has(0 /* Message */))
+          return;
+        this.emit("messageUpdate", message);
+        break;
+      }
+      case v10.GatewayDispatchEvents.MessageDelete: {
+        this.emit("messageDelete", {
+          id: payload.d.id,
+          channelId: payload.d.channel_id,
+          guildId: payload.d.guild_id
+        });
+        break;
+      }
+      case v10.GatewayDispatchEvents.UserUpdate: {
+        payload.d.id === this.#user?.id && (this.#user = new User(this, payload.d)), this.emit("userUpdate", new User(this, payload.d));
+        break;
+      }
+      case v10.GatewayDispatchEvents.GuildCreate: {
+        let guild = this.guilds.get(payload.d.id);
+        guild ? guild._patch(payload.d) : guild = new Guild(this, payload.d), this.guilds.set(payload.d.id, guild), payload.d.unavailable ? this.emit("guildCreate", guild) : this.emit("guildAvailable", guild);
+        break;
+      }
+      case v10.GatewayDispatchEvents.GuildDelete: {
+        let guild = this.guilds.get(payload.d.id);
+        if (!guild)
+          return;
+        this.guilds.delete(payload.d.id), this.emit("guildDelete", guild);
+        break;
+      }
+      case v10.GatewayDispatchEvents.GuildUpdate: {
+        let guild = this.guilds.get(payload.d.id);
+        guild ? guild._patch(payload.d) : (guild = new Guild(this, payload.d), this.guilds.set(payload.d.id, guild)), this.emit("guildUpdate", guild);
+        break;
+      }
+      case v10.GatewayDispatchEvents.ChannelCreate: {
+        let channel = createChannel(this, payload.d);
+        if (!channel)
+          return;
+        channel.inGuild() && channel.guild.channels.set(channel.id, channel), this.emit("channelCreate", channel);
+        break;
+      }
+      case v10.GatewayDispatchEvents.ChannelUpdate: {
+        let guild = this.guilds.get(payload.d.guild_id);
+        if (!guild)
+          return;
+        let channel = guild.channels.get(payload.d.id);
+        if (channel)
+          channel._patch(payload.d);
+        else {
+          if (channel = createChannel(this, payload.d), !channel)
+            return;
+          guild.channels.set(payload.d.id, channel);
+        }
+        this.emit("channelUpdate", channel);
+        break;
+      }
+      case v10.GatewayDispatchEvents.ChannelDelete: {
+        let guild = this.guilds.get(payload.d.guild_id);
+        if (!guild)
+          return;
+        let channel = guild.channels.get(payload.d.id);
+        if (!channel)
+          return;
+        guild.channels.delete(payload.d.id), this.emit("channelDelete", channel);
+        break;
+      }
+    }
+  }
+  /**
+   * We use this method to emit ready event only once since we have 2 ways to emit it.
+   * @private
+   */
+  #tryEmitReady() {
+    this.#ready || !this.#user || !this.shards.ready || (this.#ready = true, this.emit("ready", this.#user));
+  }
+};
+function createClient(options) {
+  return new Client(options);
+}
+
+Object.defineProperty(exports, "Cluster", {
+  enumerable: true,
+  get: function () { return gateway.Cluster; }
+});
+Object.defineProperty(exports, "Shard", {
+  enumerable: true,
+  get: function () { return gateway.Shard; }
+});
+Object.defineProperty(exports, "ShardState", {
+  enumerable: true,
+  get: function () { return gateway.ShardState; }
+});
+Object.defineProperty(exports, "ShardStrategy", {
+  enumerable: true,
+  get: function () { return gateway.ShardStrategy; }
+});
+Object.defineProperty(exports, "ShardingManager", {
+  enumerable: true,
+  get: function () { return gateway.ShardingManager; }
+});
+Object.defineProperty(exports, "DEFAULT_REST_OPTIONS", {
+  enumerable: true,
+  get: function () { return rest.DEFAULT_REST_OPTIONS; }
+});
+Object.defineProperty(exports, "DiscordHTTPError", {
+  enumerable: true,
+  get: function () { return rest.DiscordHTTPError; }
+});
+Object.defineProperty(exports, "REST", {
+  enumerable: true,
+  get: function () { return rest.REST; }
+});
+Object.defineProperty(exports, "RESTAdapter", {
+  enumerable: true,
+  get: function () { return rest.RESTAdapter; }
+});
+Object.defineProperty(exports, "RESTMethod", {
+  enumerable: true,
+  get: function () { return rest.RESTMethod; }
+});
+Object.defineProperty(exports, "createREST", {
+  enumerable: true,
+  get: function () { return rest.createREST; }
+});
+Object.defineProperty(exports, "createRESTAdapter", {
+  enumerable: true,
+  get: function () { return rest.createRESTAdapter; }
+});
+Object.defineProperty(exports, "Service", {
+  enumerable: true,
+  get: function () { return service.Service; }
+});
+Object.defineProperty(exports, "ServiceDriver", {
+  enumerable: true,
+  get: function () { return service.ServiceDriver; }
+});
+Object.defineProperty(exports, "ServiceProcess", {
+  enumerable: true,
+  get: function () { return service.ServiceProcess; }
+});
+Object.defineProperty(exports, "ServiceState", {
+  enumerable: true,
+  get: function () { return service.ServiceState; }
+});
+Object.defineProperty(exports, "TransportClient", {
+  enumerable: true,
+  get: function () { return service.TransportClient; }
+});
+Object.defineProperty(exports, "TransportServer", {
+  enumerable: true,
+  get: function () { return service.TransportServer; }
+});
+Object.defineProperty(exports, "createService", {
+  enumerable: true,
+  get: function () { return service.createService; }
+});
+Object.defineProperty(exports, "createTransportClient", {
+  enumerable: true,
+  get: function () { return service.createTransportClient; }
+});
+Object.defineProperty(exports, "createTransportServer", {
+  enumerable: true,
+  get: function () { return service.createTransportServer; }
+});
+Object.defineProperty(exports, "capitalize", {
+  enumerable: true,
+  get: function () { return utils.capitalize; }
+});
+Object.defineProperty(exports, "instanceToObject", {
+  enumerable: true,
+  get: function () { return utils.instanceToObject; }
+});
+Object.defineProperty(exports, "isCommonJS", {
+  enumerable: true,
+  get: function () { return utils.isCommonJS; }
+});
+Object.defineProperty(exports, "isESM", {
+  enumerable: true,
+  get: function () { return utils.isESM; }
+});
+Object.defineProperty(exports, "isPlainObject", {
+  enumerable: true,
+  get: function () { return utils.isPlainObject; }
+});
+Object.defineProperty(exports, "isPromiseLike", {
+  enumerable: true,
+  get: function () { return utils.isPromiseLike; }
+});
+Object.defineProperty(exports, "promisify", {
+  enumerable: true,
+  get: function () { return utils.promisify; }
+});
+Object.defineProperty(exports, "sleep", {
+  enumerable: true,
+  get: function () { return utils.sleep; }
+});
+exports.DiscordAPIV10 = v10__namespace;
+Object.defineProperty(exports, "Intent", {
+  enumerable: true,
+  get: function () { return v10.GatewayIntentBits; }
+});
+exports.BaseChannel = BaseChannel;
+exports.Client = Client;
+exports.ClientHelper = ClientHelper;
+exports.Guild = Guild;
+exports.GuildTextChannel = GuildTextChannel;
+exports.GuildVoiceChannel = GuildVoiceChannel;
+exports.IntentsBitField = IntentsBitField;
+exports.Message = Message;
+exports.Partial = Partial;
+exports.User = User;
+exports.createClient = createClient;