lunibee 0.1.0 → 0.1.2

package/dist/structures/index.js

@@ -0,0 +1,571 @@
+// @bun
+// packages/structures/src/base.ts
+class BaseStructure {
+  id;
+  constructor(id) {
+    if (!/^\d{1,20}$/.test(id))
+      throw new TypeError("A Discord structure requires a valid snowflake ID.");
+    this.id = id;
+  }
+  toString() {
+    return this.id;
+  }
+}
+
+class User extends BaseStructure {
+  username;
+  globalName;
+  avatar;
+  bot;
+  system;
+  flags;
+  constructor(data) {
+    super(data.id);
+    if (!data.username)
+      throw new TypeError("A Discord user requires a username.");
+    this.username = data.username;
+    this.globalName = data.global_name ?? null;
+    this.avatar = data.avatar ?? null;
+    this.bot = data.bot ?? false;
+    this.system = data.system ?? false;
+    this.flags = data.public_flags ?? 0;
+  }
+  get displayName() {
+    return this.globalName ?? this.username;
+  }
+  avatarURL(options = {}) {
+    if (!this.avatar)
+      return null;
+    const extension = options.extension ?? (this.avatar.startsWith("a_") ? "gif" : "png");
+    return `https://cdn.discordapp.com/avatars/${this.id}/${this.avatar}.${extension}${options.size ? `?size=${options.size}` : ""}`;
+  }
+  defaultAvatarURL() {
+    return `https://cdn.discordapp.com/embed/avatars/${Number(BigInt(this.id) % 5n)}.png`;
+  }
+  displayAvatarURL(options = {}) {
+    return this.avatarURL(options) ?? this.defaultAvatarURL();
+  }
+}
+
+class Channel extends BaseStructure {
+  type;
+  name;
+  guildId;
+  #context;
+  constructor(data, context) {
+    super(data.id);
+    if (!Number.isInteger(data.type) || data.type < 0)
+      throw new RangeError("A Discord channel requires a valid channel type.");
+    this.type = data.type;
+    this.name = data.name;
+    this.guildId = data.guild_id;
+    this.#context = context;
+  }
+  sendMessage(options) {
+    if (!this.#context)
+      throw new Error("This channel is not attached to a client.");
+    return this.#context.sendMessage(this.id, options);
+  }
+}
+
+class Guild extends BaseStructure {
+  name;
+  preferredLocale;
+  ownerId;
+  constructor(data) {
+    super(data.id);
+    if (!data.name)
+      throw new TypeError("A Discord guild requires a name.");
+    this.name = data.name;
+    this.preferredLocale = data.preferred_locale;
+    this.ownerId = data.owner_id;
+  }
+}
+// packages/structures/src/permissions.ts
+var Permissions = {
+  CreateInstantInvite: 1n << 0n,
+  KickMembers: 1n << 1n,
+  BanMembers: 1n << 2n,
+  Administrator: 1n << 3n,
+  ManageChannels: 1n << 4n,
+  ManageGuild: 1n << 5n,
+  AddReactions: 1n << 6n,
+  ViewAuditLog: 1n << 7n,
+  PrioritySpeaker: 1n << 8n,
+  Stream: 1n << 9n,
+  ViewChannel: 1n << 10n,
+  SendMessages: 1n << 11n,
+  SendTTSMessages: 1n << 12n,
+  ManageMessages: 1n << 13n,
+  EmbedLinks: 1n << 14n,
+  AttachFiles: 1n << 15n,
+  ReadMessageHistory: 1n << 16n,
+  MentionEveryone: 1n << 17n,
+  UseExternalEmojis: 1n << 18n,
+  ViewGuildInsights: 1n << 19n,
+  Connect: 1n << 20n,
+  Speak: 1n << 21n,
+  MuteMembers: 1n << 22n,
+  DeafenMembers: 1n << 23n,
+  MoveMembers: 1n << 24n,
+  UseVAD: 1n << 25n,
+  ChangeNickname: 1n << 26n,
+  ManageNicknames: 1n << 27n,
+  ManageRoles: 1n << 28n,
+  ManageWebhooks: 1n << 29n,
+  ManageGuildExpressions: 1n << 30n,
+  UseApplicationCommands: 1n << 31n,
+  RequestToSpeak: 1n << 32n,
+  ManageEvents: 1n << 33n,
+  ManageThreads: 1n << 34n,
+  CreatePublicThreads: 1n << 35n,
+  CreatePrivateThreads: 1n << 36n,
+  UseExternalStickers: 1n << 37n,
+  SendMessagesInThreads: 1n << 38n,
+  UseEmbeddedActivities: 1n << 39n,
+  ModerateMembers: 1n << 40n,
+  ViewCreatorMonetizationAnalytics: 1n << 41n,
+  UseSoundboard: 1n << 42n,
+  CreateGuildExpressions: 1n << 43n,
+  CreateEvents: 1n << 44n,
+  UseExternalSounds: 1n << 45n,
+  SendVoiceMessages: 1n << 46n,
+  SendPolls: 1n << 49n,
+  UseExternalApps: 1n << 50n
+};
+
+class PermissionSet {
+  bitfield;
+  constructor(value = 0n) {
+    try {
+      if (Array.isArray(value)) {
+        let bit = 0n;
+        for (const item of value)
+          bit |= this.#resolve(item);
+        this.bitfield = bit;
+      } else if (value instanceof PermissionSet) {
+        this.bitfield = value.bitfield;
+      } else {
+        const bitfield = this.#resolve(value);
+        if (bitfield < 0n)
+          throw new RangeError("Permission bitfield cannot be negative.");
+        this.bitfield = bitfield;
+      }
+    } catch (error) {
+      if (error instanceof RangeError)
+        throw error;
+      throw new TypeError("Permission bitfield must be a valid non-negative integer.", { cause: error });
+    }
+  }
+  has(...permissions) {
+    return permissions.every((permission) => (this.bitfield & this.#resolve(permission)) === this.#resolve(permission));
+  }
+  any(...permissions) {
+    return permissions.some((permission) => (this.bitfield & this.#resolve(permission)) !== 0n);
+  }
+  add(...permissions) {
+    let bitfield = this.bitfield;
+    for (const permission of permissions)
+      bitfield |= this.#resolve(permission);
+    return new PermissionSet(bitfield);
+  }
+  remove(...permissions) {
+    let bitfield = this.bitfield;
+    for (const permission of permissions)
+      bitfield &= ~this.#resolve(permission);
+    return new PermissionSet(bitfield);
+  }
+  equals(other) {
+    return this.bitfield === (other instanceof PermissionSet ? other.bitfield : new PermissionSet(other).bitfield);
+  }
+  toString() {
+    return this.bitfield.toString();
+  }
+  toArray() {
+    return Object.keys(Permissions).filter((permission) => this.has(permission));
+  }
+  #resolve(permission) {
+    if (permission instanceof PermissionSet)
+      return permission.bitfield;
+    if (typeof permission === "bigint")
+      return permission;
+    if (typeof permission === "number")
+      return BigInt(permission);
+    if (Array.isArray(permission)) {
+      let bit = 0n;
+      for (const p of permission)
+        bit |= this.#resolve(p);
+      return bit;
+    }
+    if (typeof permission === "string") {
+      if (permission in Permissions)
+        return Permissions[permission];
+      const matchedKey = Object.keys(Permissions).find((k) => k.toLowerCase() === permission.toLowerCase());
+      if (matchedKey)
+        return Permissions[matchedKey];
+      return BigInt(permission);
+    }
+    return 0n;
+  }
+}
+
+class PermissionsBitField extends PermissionSet {
+  constructor(value = 0n) {
+    super(value);
+  }
+}
+
+// packages/structures/src/resources.ts
+class GuildMember {
+  user;
+  guildId;
+  nickname;
+  roleIds;
+  pending;
+  joinedAt;
+  permissions;
+  constructor(data) {
+    this.user = new User(data.user);
+    if (!/^\d{1,20}$/.test(data.guild_id))
+      throw new TypeError("Member guild_id must be a valid snowflake.");
+    this.guildId = data.guild_id;
+    this.nickname = data.nick ?? null;
+    this.roleIds = [...data.roles ?? []];
+    this.pending = data.pending ?? false;
+    this.joinedAt = data.joined_at ? new Date(data.joined_at) : undefined;
+    if (this.joinedAt?.toString() === "Invalid Date")
+      throw new RangeError("Member joined_at must be a valid date.");
+    this.permissions = new PermissionsBitField(data.permissions ?? 0n);
+  }
+  get displayName() {
+    return this.nickname ?? this.user.displayName;
+  }
+}
+
+class Role extends BaseStructure {
+  name;
+  color;
+  hoist;
+  permissions;
+  managed;
+  mentionable;
+  constructor(data) {
+    super(data.id);
+    if (!data.name)
+      throw new TypeError("Role name cannot be empty.");
+    this.name = data.name;
+    this.color = data.color ?? 0;
+    this.hoist = data.hoist ?? false;
+    this.permissions = new PermissionsBitField(data.permissions ?? 0n);
+    this.managed = data.managed ?? false;
+    this.mentionable = data.mentionable ?? false;
+  }
+  toString() {
+    return `<@&${this.id}>`;
+  }
+}
+
+class TextChannel extends Channel {
+  parentId;
+  constructor(data) {
+    super(data);
+    this.parentId = data.parent_id;
+  }
+  toString() {
+    return `<#${this.id}>`;
+  }
+}
+// packages/structures/src/interactions.ts
+var InteractionType = {
+  Ping: 1,
+  ApplicationCommand: 2,
+  MessageComponent: 3,
+  ApplicationCommandAutocomplete: 4,
+  ModalSubmit: 5
+};
+var InteractionResponseType = {
+  Pong: 1,
+  ChannelMessage: 4,
+  DeferredChannelMessage: 5,
+  DeferredMessageUpdate: 6,
+  MessageUpdate: 7,
+  Autocomplete: 8,
+  Modal: 9
+};
+
+class InteractionResponse {
+  type;
+  data;
+  constructor(type, data) {
+    if (!Number.isFinite(type))
+      throw new TypeError("Interaction response type must be finite.");
+    this.type = type;
+    this.data = data;
+  }
+  toJSON() {
+    return this.data === undefined ? { type: this.type } : { type: this.type, data: this.data };
+  }
+  static message(options) {
+    const data = { ...options };
+    if (options.ephemeral) {
+      data.flags = (typeof options.flags === "number" ? options.flags : 0) | 64;
+    }
+    return new InteractionResponse(InteractionResponseType.ChannelMessage, data);
+  }
+  static defer(ephemeral = false) {
+    return new InteractionResponse(InteractionResponseType.DeferredChannelMessage, ephemeral ? { flags: 64 } : undefined);
+  }
+  static pong() {
+    return new InteractionResponse(InteractionResponseType.Pong);
+  }
+}
+
+class Interaction {
+  id;
+  applicationId;
+  token;
+  guildId;
+  channelId;
+  type;
+  data;
+  replied = false;
+  deferred = false;
+  #client;
+  constructor(client, data) {
+    if (!data.id || !data.token)
+      throw new TypeError("Interaction ID and token are required.");
+    this.#client = client;
+    this.id = data.id;
+    this.applicationId = data.application_id;
+    this.token = data.token;
+    this.guildId = data.guild_id;
+    this.channelId = data.channel_id;
+    this.type = data.type;
+    this.data = data;
+  }
+  isChatInputCommand() {
+    return this.type === InteractionType.ApplicationCommand;
+  }
+  isMessageComponent() {
+    return this.type === InteractionType.MessageComponent;
+  }
+  isModalSubmit() {
+    return this.type === InteractionType.ModalSubmit;
+  }
+  isAutocomplete() {
+    return this.type === InteractionType.ApplicationCommandAutocomplete;
+  }
+  assertUnacknowledged() {
+    if (this.replied || this.deferred)
+      throw new Error("Interaction has already been acknowledged.");
+  }
+  assertAcknowledged() {
+    if (!this.replied && !this.deferred)
+      throw new Error("Interaction has not been acknowledged.");
+  }
+  postResponse(response) {
+    return this.#client.postInteractionResponse(this.id, this.token, response);
+  }
+  async reply(options) {
+    this.assertUnacknowledged();
+    const payload = typeof options === "string" ? { content: options } : options;
+    const result = await this.#client.postInteractionResponse(this.id, this.token, InteractionResponse.message(payload));
+    this.replied = true;
+    return result;
+  }
+  async deferReply(ephemeral = false) {
+    this.assertUnacknowledged();
+    await this.#client.postInteractionResponse(this.id, this.token, InteractionResponse.defer(ephemeral));
+    this.deferred = true;
+  }
+  editReply(options) {
+    this.assertAcknowledged();
+    return this.#client.editInteractionReply(this.token, options);
+  }
+  deleteReply() {
+    this.assertAcknowledged();
+    return this.#client.deleteInteractionReply(this.token);
+  }
+  followUp(options) {
+    const payload = typeof options === "string" ? { content: options } : options;
+    return this.#client.followUpInteraction(this.token, payload);
+  }
+  async update(options) {
+    this.assertUnacknowledged();
+    const payload = typeof options === "string" ? { content: options } : options;
+    const result = await this.#client.postInteractionResponse(this.id, this.token, new InteractionResponse(InteractionResponseType.MessageUpdate, payload));
+    this.replied = true;
+    return result;
+  }
+  async showModal(modal) {
+    this.assertUnacknowledged();
+    const result = await this.#client.postInteractionResponse(this.id, this.token, new InteractionResponse(InteractionResponseType.Modal, modal));
+    this.replied = true;
+    return result;
+  }
+}
+
+class CommandInteraction extends Interaction {
+  get commandName() {
+    return typeof this.data.data?.name === "string" ? this.data.data.name : "";
+  }
+}
+
+class ComponentInteraction extends Interaction {
+  get customId() {
+    return this.data?.data?.custom_id ?? "";
+  }
+  get componentType() {
+    return this.data?.data?.component_type ?? 0;
+  }
+  get values() {
+    return this.data?.data?.values ?? [];
+  }
+  async deferUpdate() {
+    this.assertUnacknowledged();
+    await this.postResponse(new InteractionResponse(InteractionResponseType.DeferredMessageUpdate));
+    this.deferred = true;
+  }
+  async update(options) {
+    this.assertUnacknowledged();
+    const payload = typeof options === "string" ? { content: options } : options;
+    const result = await this.postResponse(new InteractionResponse(InteractionResponseType.MessageUpdate, payload));
+    this.replied = true;
+    return result;
+  }
+}
+function createInteraction(client, data) {
+  switch (data.type) {
+    case InteractionType.ApplicationCommand:
+    case InteractionType.ApplicationCommandAutocomplete:
+      return new CommandInteraction(client, data);
+    case InteractionType.MessageComponent:
+    case InteractionType.ModalSubmit:
+      return new ComponentInteraction(client, data);
+    default:
+      return new Interaction(client, data);
+  }
+}
+
+class ModalSubmitInteraction extends Interaction {
+  get customId() {
+    return this.data?.data?.custom_id ?? "";
+  }
+  getInputValue(customId) {
+    const rows = this.data?.data?.components ?? [];
+    for (const row of rows) {
+      for (const comp of row.components ?? []) {
+        if (comp.custom_id === customId)
+          return comp.value;
+      }
+    }
+    return;
+  }
+}
+
+class AutocompleteInteraction extends Interaction {
+  get commandName() {
+    return this.data?.data?.name ?? "";
+  }
+  get focusedOption() {
+    const options = this.data?.data?.options ?? [];
+    return options.find((opt) => opt.focused);
+  }
+  async respond(choices) {
+    const response = new InteractionResponse(InteractionResponseType.Autocomplete, { choices });
+    await this.postResponse(response);
+  }
+}
+
+// packages/structures/src/index.ts
+class Message extends BaseStructure {
+  content;
+  author;
+  channelId;
+  channel;
+  guildId;
+  flags;
+  createdAt;
+  attachments;
+  embeds;
+  mentions;
+  mentionRoles;
+  pinned;
+  mentionEveryone;
+  type;
+  reference;
+  referencedMessage;
+  #context;
+  constructor(data, context) {
+    super(data.id);
+    if (!/^\d{1,20}$/.test(data.channel_id))
+      throw new TypeError("Message channel_id must be a valid snowflake.");
+    this.content = data.content ?? "";
+    this.author = new User(data.author);
+    this.channelId = data.channel_id;
+    this.guildId = data.guild_id;
+    this.flags = data.flags ?? 0;
+    this.createdAt = new Date(data.timestamp ?? Number((BigInt(this.id) >> 22n) + 1420070400000n));
+    this.attachments = data.attachments ?? [];
+    this.embeds = data.embeds ?? [];
+    this.mentions = (data.mentions ?? []).map((user) => new User(user));
+    this.mentionRoles = data.mention_roles ?? [];
+    this.pinned = data.pinned ?? false;
+    this.mentionEveryone = data.mention_everyone ?? false;
+    this.type = data.type ?? 0;
+    this.reference = data.message_reference;
+    this.referencedMessage = data.referenced_message ? new Message(data.referenced_message, context) : data.referenced_message === null ? null : undefined;
+    this.#context = context;
+    this.channel = new Channel({ id: data.channel_id, type: 0, guild_id: data.guild_id }, context);
+  }
+  get embedsSuppressed() {
+    return (this.flags & 4) !== 0;
+  }
+  edit(options) {
+    if (!this.#context)
+      throw new Error("This message is not attached to a client.");
+    return this.#context.editMessage(this.channelId, this.id, options);
+  }
+  delete() {
+    if (!this.#context)
+      throw new Error("This message is not attached to a client.");
+    return this.#context.deleteMessage(this.channelId, this.id);
+  }
+  crosspost() {
+    if (!this.#context)
+      throw new Error("This message is not attached to a client.");
+    return this.#context.crosspostMessage(this.channelId, this.id);
+  }
+  reply(options) {
+    if (!this.#context)
+      throw new Error("This message is not attached to a client.");
+    const payload = typeof options === "string" ? { content: options } : { ...options };
+    payload.message_reference = {
+      message_id: this.id,
+      channel_id: this.channelId,
+      guild_id: this.guildId
+    };
+    return this.#context.sendMessage(this.channelId, payload);
+  }
+}
+export {
+  AutocompleteInteraction,
+  BaseStructure,
+  Channel,
+  CommandInteraction,
+  ComponentInteraction,
+  Guild,
+  GuildMember,
+  Interaction,
+  InteractionResponse,
+  InteractionResponseType,
+  InteractionType,
+  Message,
+  ModalSubmitInteraction,
+  Role,
+  TextChannel,
+  User,
+  createInteraction
+};
+
+//# debugId=EDF445FCBD7D61B564756E2164756E21