disgroove 1.3.1 → 1.3.3-dev.1

package/lib/structures/Message.ts

@@ -0,0 +1,421 @@
+import {
+  Application,
+  Base,
+  Channel,
+  Emoji,
+  GuildMember,
+  Role,
+  Sticker,
+  User,
+} from ".";
+import type { Client } from "../Client";
+import { Endpoints, type File } from "../rest";
+import type {
+  JSONActionRow,
+  JSONAllowedMentions,
+  JSONAttachment,
+  JSONChannelMention,
+  JSONEmbed,
+  JSONMessage,
+  JSONMessageActivity,
+  JSONMessageCreateEventExtraFields,
+  JSONMessageInteraction,
+  JSONMessageReference,
+  JSONReaction,
+  JSONResolvedData,
+  JSONRoleSubscriptionData,
+  JSONStickerItem,
+  RawChannel,
+  RawMessage,
+  RawMessageCreateEventExtraFields,
+  RawUser,
+} from "../types";
+import { MessageFlags, MessageTypes } from "../constants";
+
+/** https://discord.com/developers/docs/resources/channel */
+export class Message extends Base {
+  protected override raw: RawMessage &
+    Partial<RawMessageCreateEventExtraFields>;
+  channelId: string;
+  author: User;
+  content: string;
+  timestamp: string;
+  editedTimestamp: string | null;
+  tts: boolean;
+  mentionEveryone: boolean;
+  mentions: Array<User>;
+  mentionRoles: Array<string>;
+  mentionChannels?: Array<JSONChannelMention>;
+  attachments: Array<JSONAttachment>;
+  embeds: Array<JSONEmbed>;
+  reactions?: Array<JSONReaction>;
+  nonce?: number | string;
+  pinned: boolean;
+  webhookId?: string;
+  type: MessageTypes;
+  activity?: JSONMessageActivity;
+  application?: Application;
+  applicationId?: string;
+  messageReference?: JSONMessageReference;
+  flags?: MessageFlags;
+  referencedMessage?: Message | null;
+  interaction?: JSONMessageInteraction;
+  thread?: Channel;
+  components?: Array<JSONActionRow>;
+  stickerItems?: Array<JSONStickerItem>;
+  stickers?: Array<Sticker>;
+  position?: number;
+  roleSubscriptionData?: JSONRoleSubscriptionData;
+  resolved?: JSONResolvedData;
+  guildId?: string;
+  member?: GuildMember;
+
+  constructor(
+    data: RawMessage & Partial<RawMessageCreateEventExtraFields>,
+    client: Client
+  ) {
+    super(data.id, client);
+
+    this.raw = data;
+    this.channelId = data.channel_id;
+    this.author = new User(data.author, this.client);
+    this.content = data.content;
+    this.timestamp = data.timestamp;
+    this.editedTimestamp =
+      data.edited_timestamp !== null ? data.edited_timestamp : null;
+    this.mentions = data.mentions.map((user) => new User(user, this.client));
+    this.mentionRoles = data.mention_roles;
+    this.attachments = data.attachments.map((attachment) =>
+      this.client.util.attachmentToJSON(attachment)
+    );
+    this.embeds = this.client.util.embedsToJSON(data.embeds);
+    this.tts = data.tts;
+    this.mentionEveryone = data.mention_everyone;
+    this.pinned = data.pinned;
+    this.type = data.type;
+
+    this.patch(data);
+  }
+
+  protected override patch(
+    data: RawMessage & Partial<RawMessageCreateEventExtraFields>
+  ): void {
+    if (data.mention_channels !== undefined)
+      this.mentionChannels = data.mention_channels.map((mentionChannel) => ({
+        id: mentionChannel.id,
+        guildId: mentionChannel.guild_id,
+        type: mentionChannel.type,
+        name: mentionChannel.name,
+      }));
+    if (data.reactions !== undefined)
+      this.reactions = data.reactions.map((reaction) => ({
+        count: reaction.count,
+        countDetails: reaction.count_details,
+        me: reaction.me,
+        meBurst: reaction.me_burst,
+        emoji: new Emoji(reaction.emoji, this.client).toJSON(),
+        burstColors: reaction.burst_colors,
+      }));
+    if (data.nonce !== undefined) this.nonce = data.nonce;
+    if (data.webhook_id !== undefined) this.webhookId = data.webhook_id;
+    if (data.activity !== undefined) this.activity = data.activity;
+    if (data.application !== undefined)
+      this.application = new Application(data.application, this.client);
+    if (data.application_id !== undefined)
+      this.applicationId = data.application_id;
+    if (data.message_reference !== undefined)
+      this.messageReference = {
+        messageId: data.message_reference.message_id,
+        channelId: data.message_reference.channel_id,
+        guildId: data.message_reference.guild_id,
+        failIfNotExists: data.message_reference.fail_if_not_exists,
+      };
+    if (data.flags !== undefined) this.flags = data.flags;
+    if (data.referenced_message !== undefined)
+      this.referencedMessage =
+        data.referenced_message !== null
+          ? new Message(data.referenced_message, this.client)
+          : null;
+    if (data.interaction !== undefined)
+      this.interaction = {
+        id: data.interaction.id,
+        type: data.interaction.type,
+        name: data.interaction.name,
+        user: new User(data.interaction.user, this.client),
+        member:
+          data.interaction.member !== undefined
+            ? new GuildMember(data.interaction.member, this.client)
+            : undefined,
+      };
+    if (data.thread !== undefined)
+      this.thread = new Channel(data.thread, this.client);
+    if (data.components !== undefined)
+      this.components = this.client.util.messageComponentsToJSON(
+        data.components
+      );
+    if (data.sticker_items !== undefined)
+      this.stickerItems = data.sticker_items.map((stickerItem) => ({
+        id: stickerItem.id,
+        name: stickerItem.name,
+        formatType: stickerItem.format_type,
+      }));
+    if (data.stickers !== undefined)
+      this.stickers = data.stickers.map(
+        (sticker) => new Sticker(sticker, this.client)
+      );
+    if (data.position !== undefined) this.position = data.position;
+    if (data.role_subscription_data !== undefined)
+      this.roleSubscriptionData = {
+        roleSubscriptionListingId:
+          data.role_subscription_data.role_subscription_listing_id,
+        tierName: data.role_subscription_data.tier_name,
+        totalMonthsSubscribed:
+          data.role_subscription_data.total_months_subscribed,
+        isRenewal: data.role_subscription_data.is_renewal,
+      };
+    if (data.resolved !== undefined)
+      this.resolved = {
+        users:
+          data.resolved?.users !== undefined
+            ? new Map(
+                Object.entries(data.resolved.users).map(([id, user]) => [
+                  id,
+                  new User(user, this.client).toJSON(),
+                ])
+              )
+            : undefined,
+        members:
+          data.resolved?.members !== undefined
+            ? new Map(
+                Object.entries(data.resolved.members).map(([id, member]) => [
+                  id,
+                  new GuildMember(member, this.client).toJSON(),
+                ])
+              )
+            : undefined,
+        roles:
+          data.resolved?.roles !== undefined
+            ? new Map(
+                Object.entries(data.resolved.roles).map(([id, role]) => [
+                  id,
+                  new Role(role, this.client).toJSON(),
+                ])
+              )
+            : undefined,
+        channels:
+          data.resolved?.channels !== undefined
+            ? new Map(
+                Object.entries(data.resolved.channels).map(([id, channel]) => [
+                  id,
+                  new Channel(channel, this.client).toJSON(),
+                ])
+              )
+            : undefined,
+        messages:
+          data.resolved?.messages !== undefined
+            ? new Map(
+                Object.entries(data.resolved.messages).map(([id, message]) => [
+                  id,
+                  new Message(message, this.client).toJSON(),
+                ])
+              )
+            : undefined,
+        attachments:
+          data.resolved?.attachments !== undefined
+            ? new Map(
+                Object.entries(data.resolved.attachments).map(
+                  ([id, attachment]) => [
+                    id,
+                    this.client.util.attachmentToJSON(attachment),
+                  ]
+                )
+              )
+            : undefined,
+      };
+    if (data.guild_id !== undefined) this.guildId = data.guild_id;
+    if (data.member !== undefined)
+      this.member = new GuildMember(data.member, this.client);
+  }
+
+  /** https://discord.com/developers/docs/resources/channel#create-reaction */
+  createReaction(emoji: string): void {
+    this.client.rest.put(
+      Endpoints.channelMessageReaction(this.channelId, this.id, emoji)
+    );
+  }
+
+  /** https://discord.com/developers/docs/resources/channel#start-thread-from-message */
+  async createThread(
+    options: {
+      name: string;
+      autoArchiveDuration?: number;
+      rateLimitPerUser?: number | null;
+    },
+    reason?: string
+  ): Promise<Channel> {
+    return new Channel(
+      await this.client.rest.post<RawChannel>(
+        Endpoints.threads(this.channelId, this.id),
+        {
+          json: {
+            name: options.name,
+            auto_archive_duration: options.autoArchiveDuration,
+            rate_limit_per_user: options.rateLimitPerUser,
+          },
+          reason,
+        }
+      ),
+      this.client
+    );
+  }
+
+  /** https://discord.com/developers/docs/resources/channel#crosspost-message */
+  async crosspost(): Promise<Message> {
+    return new Message(
+      await this.client.rest.post<RawMessage>(
+        Endpoints.channelMessageCrosspost(this.channelId, this.id)
+      ),
+      this.client
+    );
+  }
+
+  /** https://discord.com/developers/docs/resources/channel#delete-message */
+  delete(reason?: string): void {
+    this.client.rest.delete(Endpoints.channelMessage(this.channelId, this.id), {
+      reason,
+    });
+  }
+
+  /** https://discord.com/developers/docs/resources/channel#delete-all-reactions */
+  deleteAllReactions(emoji?: string): void {
+    this.client.rest.delete(
+      Endpoints.channelMessageAllReactions(this.channelId, this.id, emoji)
+    );
+  }
+
+  /**
+   * https://discord.com/developers/docs/resources/channel#delete-own-reaction
+   * https://discord.com/developers/docs/resources/channel#delete-user-reaction
+   */
+  deleteReaction(emoji: string, userId?: string): void {
+    this.client.rest.delete(
+      Endpoints.channelMessageReaction(this.channelId, this.id, emoji, userId)
+    );
+  }
+
+  /** https://discord.com/developers/docs/resources/channel#edit-message */
+  async edit(options: {
+    content?: string | null;
+    embeds?: Array<JSONEmbed> | null;
+    flags?: MessageFlags | null;
+    allowedMentions?: JSONAllowedMentions | null;
+    components?: Array<JSONActionRow> | null;
+    files?: Array<File> | null;
+    attachments?: Array<JSONAttachment> | null;
+  }): Promise<Message> {
+    return new Message(
+      await this.client.rest.patch<RawMessage>(
+        Endpoints.channelMessage(this.channelId, this.id),
+        {
+          json: {
+            content: options.content,
+            embeds:
+              options.embeds !== undefined
+                ? options.embeds !== null
+                  ? this.client.util.embedsToRaw(options.embeds)
+                  : null
+                : undefined,
+            allowed_mentions: options.allowedMentions,
+            components:
+              options.components !== undefined
+                ? options.components !== null
+                  ? this.client.util.messageComponentsToRaw(options.components)
+                  : null
+                : undefined,
+            attachments: options.attachments,
+            flags: options.flags,
+          },
+          files: options.files,
+        }
+      ),
+      this.client
+    );
+  }
+
+  /** https://discord.com/developers/docs/resources/channel#get-reactions */
+  async getReactions(
+    emoji: string,
+    options?: {
+      after?: string;
+      limit?: number;
+    }
+  ): Promise<Array<User>> {
+    return this.client.rest
+      .get<Array<RawUser>>(
+        Endpoints.channelMessageAllReactions(this.channelId, this.id, emoji),
+        {
+          query: {
+            after: options?.after,
+            limit: options?.limit,
+          },
+        }
+      )
+      .then((response) => response.map((data) => new User(data, this.client)));
+  }
+
+  /** https://discord.com/developers/docs/resources/channel#pin-message */
+  pin(reason?: string): void {
+    this.client.rest.put(Endpoints.channelPin(this.channelId, this.id), {
+      reason,
+    });
+  }
+
+  /** https://discord.com/developers/docs/resources/channel#unpin-message */
+  unpin(reason?: string): void {
+    this.client.rest.delete(Endpoints.channelPin(this.channelId, this.id), {
+      reason,
+    });
+  }
+
+  override toRaw(): RawMessage & Partial<RawMessageCreateEventExtraFields> {
+    return this.raw;
+  }
+
+  override toJSON(): JSONMessage & Partial<JSONMessageCreateEventExtraFields> {
+    return {
+      ...super.toJSON(),
+      channelId: this.channelId,
+      author: this.author.toJSON(),
+      content: this.content,
+      timestamp: this.timestamp,
+      editedTimestamp: this.editedTimestamp,
+      tts: this.tts,
+      mentionEveryone: this.mentionEveryone,
+      mentions: this.mentions,
+      mentionRoles: this.mentionRoles,
+      mentionChannels: this.mentionChannels,
+      attachments: this.attachments,
+      embeds: this.embeds,
+      reactions: this.reactions,
+      nonce: this.nonce,
+      pinned: this.pinned,
+      webhookId: this.webhookId,
+      type: this.type,
+      activity: this.activity,
+      application: this.application?.toJSON(),
+      applicationId: this.applicationId,
+      messageReference: this.messageReference,
+      flags: this.flags,
+      referencedMessage: this.referencedMessage?.toJSON(),
+      interaction: this.interaction,
+      thread: this.thread,
+      components: this.components,
+      stickerItems: this.stickerItems,
+      stickers: this.stickers,
+      position: this.position,
+      roleSubscriptionData: this.roleSubscriptionData,
+      guildId: this.guildId,
+      member: this.member?.toJSON(),
+    };
+  }
+}

package/lib/structures/Role.ts

@@ -0,0 +1,116 @@
+import type { Client } from "../Client";
+import { Endpoints } from "../rest";
+import type { JSONRole, JSONRoleTags, RawRole } from "../types";
+import { Base } from ".";
+import { RoleFlags } from "../constants";
+
+/** https://discord.com/developers/docs/topics/permissions */
+export class Role extends Base {
+  protected override raw: RawRole;
+  name: string;
+  color: number;
+  hoist: boolean;
+  icon?: string | null;
+  unicodeEmoji?: string | null;
+  position: number;
+  permissions: string;
+  managed: boolean;
+  mentionable: boolean;
+  tags?: JSONRoleTags;
+  flags: RoleFlags;
+
+  constructor(data: RawRole, client: Client) {
+    super(data.id, client);
+
+    this.raw = data;
+    this.name = data.name;
+    this.color = data.color;
+    this.hoist = data.hoist;
+    this.position = data.position;
+    this.permissions = data.permissions;
+    this.managed = data.managed;
+    this.mentionable = data.mentionable;
+    this.flags = data.flags;
+
+    this.patch(data);
+  }
+
+  protected override patch(data: RawRole): void {
+    if (data.icon !== undefined) this.icon = data.icon;
+    if (data.unicode_emoji !== undefined)
+      this.unicodeEmoji = data.unicode_emoji;
+    if (data.tags !== undefined)
+      this.tags = {
+        botId: data.tags.bot_id,
+        integrationId: data.tags.integration_id,
+        premiumSubscriber: data.tags.premium_subscriber,
+        subscriptionListingId: data.tags.subscription_listing_id,
+        availableForPurchase: data.tags.available_for_purchase,
+        guildConnections: data.tags.guild_connections,
+      };
+  }
+
+  /** https://discord.com/developers/docs/resources/guild#delete-guild-role */
+  delete(guildId: string, reason?: string): void {
+    this.client.rest.delete(Endpoints.guildRole(guildId, this.id), {
+      reason,
+    });
+  }
+
+  /** https://discord.com/developers/docs/resources/guild#modify-guild-role */
+  async edit(
+    guildId: string,
+    options?: {
+      name?: string | null;
+      permissions?: string | null;
+      color?: number | null;
+      hoist?: boolean | null;
+      icon?: string | null;
+      unicodeEmoji?: string | null;
+      mentionable?: boolean | null;
+    },
+    reason?: string
+  ): Promise<Role> {
+    return new Role(
+      await this.client.rest.patch<RawRole>(
+        Endpoints.guildRole(guildId, this.id),
+        {
+          json: {
+            name: options?.name,
+            permissions: options?.permissions,
+            color: options?.color,
+            hoist: options?.hoist,
+            icon: options?.icon,
+            unicode_emoji: options?.unicodeEmoji,
+            mentionable: options?.mentionable,
+          },
+          reason,
+        }
+      ),
+      this.client
+    );
+  }
+
+  override toRaw(): RawRole & {
+    guild_id?: string;
+  } {
+    return this.raw;
+  }
+
+  override toJSON(): JSONRole {
+    return {
+      ...super.toJSON(),
+      name: this.name,
+      color: this.color,
+      hoist: this.hoist,
+      icon: this.icon,
+      unicodeEmoji: this.unicodeEmoji,
+      position: this.position,
+      permissions: this.permissions,
+      managed: this.managed,
+      mentionable: this.mentionable,
+      tags: this.tags,
+      flags: this.flags,
+    };
+  }
+}

package/lib/structures/SKU.ts

@@ -0,0 +1,63 @@
+import type { Client } from "../Client";
+import type { JSONSKU, RawSKU } from "../types";
+import { Base } from ".";
+import type { SKUFlags, SKUTypes } from "../constants";
+
+/** https://discord.com/developers/docs/monetization/skus */
+export class SKU extends Base {
+  protected override raw: RawSKU;
+  type: SKUTypes;
+  dependentSKUId?: string | null; // Undocumented
+  applicationId: string;
+  manifestLabels?: null; // Undocumented
+  accessType?: number; // Undocumented
+  name: string;
+  features?: []; // Undocumented
+  releaseDate?: null; // Undocumented
+  slug: string;
+  flags: SKUFlags;
+  showAgeGate?: boolean; // Undocumented
+
+  constructor(data: RawSKU, client: Client) {
+    super(data.id, client);
+
+    this.raw = data;
+    this.type = data.type;
+    this.applicationId = data.application_id;
+    this.name = data.name;
+    this.slug = data.slug;
+    this.flags = data.flags;
+  }
+
+  protected override patch(data: RawSKU): void {
+    if (data.dependent_sku_id !== undefined)
+      this.dependentSKUId = data.dependent_sku_id;
+    if (data.manifest_labels !== undefined)
+      this.manifestLabels = data.manifest_labels;
+    if (data.access_type !== undefined) this.accessType = data.access_type;
+    if (data.features !== undefined) this.features = data.features;
+    if (data.release_date !== undefined) this.releaseDate = data.release_date;
+    if (data.show_age_gate !== undefined) this.showAgeGate = data.show_age_gate;
+  }
+
+  override toRaw(): RawSKU {
+    return this.raw;
+  }
+
+  override toJSON(): JSONSKU {
+    return {
+      id: this.id,
+      type: this.type,
+      dependentSKUId: this.dependentSKUId,
+      applicationId: this.applicationId,
+      manifestLabels: this.manifestLabels,
+      accessType: this.accessType,
+      name: this.name,
+      features: this.features,
+      releaseDate: this.releaseDate,
+      slug: this.slug,
+      flags: this.flags,
+      showAgeGate: this.showAgeGate,
+    };
+  }
+}

package/lib/structures/StageInstance.ts

@@ -0,0 +1,74 @@
+import type { Client } from "../Client";
+import { Endpoints } from "../rest";
+import type { JSONStageInstance, RawStageInstance } from "../types";
+import type { PrivacyLevel } from "../constants";
+import { Base } from ".";
+
+/** https://discord.com/developers/docs/resources/stage-instance */
+export class StageInstance extends Base {
+  protected override raw: RawStageInstance;
+  guildId: string;
+  channelId: string;
+  topic: string;
+  privacyLevel: PrivacyLevel;
+  discoverableDisabled: boolean;
+  guildScheduledEventId: string | null;
+
+  constructor(data: RawStageInstance, client: Client) {
+    super(data.id, client);
+
+    this.raw = data;
+    this.guildId = data.guild_id;
+    this.channelId = data.channel_id;
+    this.topic = data.topic;
+    this.privacyLevel = data.privacy_level;
+    this.discoverableDisabled = data.discoverable_disabled;
+    this.guildScheduledEventId = data.guild_scheduled_event_id;
+  }
+
+  /** https://discord.com/developers/docs/resources/stage-instance#delete-stage-instance */
+  delete(reason?: string): void {
+    this.client.rest.delete(Endpoints.stageInstance(this.channelId), {
+      reason,
+    });
+  }
+
+  /** https://discord.com/developers/docs/resources/stage-instance#modify-stage-instance */
+  async edit(
+    options: {
+      topic?: string;
+      privacyLevel?: PrivacyLevel;
+    },
+    reason?: string
+  ): Promise<StageInstance> {
+    return new StageInstance(
+      await this.client.rest.patch<RawStageInstance>(
+        Endpoints.stageInstance(this.channelId),
+        {
+          json: {
+            topic: options.topic,
+            privacy_level: options.privacyLevel,
+          },
+          reason,
+        }
+      ),
+      this.client
+    );
+  }
+
+  override toRaw(): RawStageInstance {
+    return this.raw;
+  }
+
+  override toJSON(): JSONStageInstance {
+    return {
+      ...super.toJSON(),
+      guildId: this.guildId,
+      channelId: this.channelId,
+      topic: this.topic,
+      privacyLevel: this.privacyLevel,
+      discoverableDisabled: this.discoverableDisabled,
+      guildScheduledEventId: this.guildScheduledEventId,
+    };
+  }
+}