@ovencord/discord.js 14.16.3

package/src/managers/GuildSoundboardSoundManager.ts

@@ -0,0 +1,157 @@
+import { Routes, type Snowflake } from 'discord-api-types/v10';
+import { DiscordjsTypeError, ErrorCodes } from '../errors/index.js';
+import { SoundboardSound } from '../structures/SoundboardSound.js';
+import { resolveBase64, resolveFile } from '../util/DataResolver.js';
+import { CachedManager } from './CachedManager.js';
+
+/**
+ * Detects the MIME type of a buffer by checking its magic bytes.
+ *
+ * @param {Buffer} data The data to check
+ * @returns {string[]}
+ */
+export function detectAudioMime(data: Buffer): string[] {
+  if (data[0] === 0x49 && data[1] === 0x44 && data[2] === 0x33) return ['audio/mpeg']; // ID3
+  if (data[0] === 0xff && (data[1] & 0xe0) === 0xe0) return ['audio/mpeg']; // MP3 Frame
+  if (data[0] === 0x52 && data[1] === 0x49 && data[2] === 0x46 && data[3] === 0x46) return ['audio/wav']; // RIFF/WAV
+  if (data[0] === 0x4f && data[1] === 0x67 && data[2] === 0x67 && data[3] === 0x53) return ['audio/ogg']; // OggS
+  if (data[0] === 0x66 && data[1] === 0x4c && data[2] === 0x61 && data[3] === 0x43) return ['audio/flac']; // fLaC
+  return ['application/octet-stream'];
+}
+
+/**
+ * Manages API methods for Soundboard Sounds and stores their cache.
+ *
+ * @extends {CachedManager}
+ */
+export class GuildSoundboardSoundManager extends CachedManager {
+  public guild: any;
+
+  constructor(guild: any, iterable: any) {
+    super(guild.client, SoundboardSound, iterable);
+
+    /**
+     * The guild this manager belongs to
+     *
+     * @type {Guild}
+     */
+    this.guild = guild;
+  }
+
+  override _add(data: any, cache: boolean) {
+    return super._add(data, cache, { extras: [this.guild], id: data.sound_id });
+  }
+
+  /**
+   * Resolves a {@link SoundboardSoundResolvable} to a {@link SoundboardSound} id.
+   *
+   * @param {any} soundboardSound The soundboard sound resolvable to resolve
+   * @returns {?Snowflake}
+   */
+  resolveId(soundboardSound: any): Snowflake | null {
+    if (soundboardSound instanceof (this as any).holds) return (soundboardSound as any).soundId;
+    if (typeof soundboardSound === 'string') return soundboardSound;
+    return null;
+  }
+
+  /**
+   * Creates a new guild soundboard sound.
+   *
+   * @param {any} options Options for creating a guild soundboard sound
+   * @returns {Promise<SoundboardSound>} The created soundboard sound
+   */
+  async create({ contentType, emojiId, emojiName, file, name, reason, volume }: any): Promise<any> {
+    const resolvedFile = await resolveFile(file);
+
+    const resolvedContentType = contentType ?? resolvedFile.contentType ?? detectAudioMime(resolvedFile.data)[0];
+
+    const sound = resolveBase64(resolvedFile.data, resolvedContentType);
+
+    const body = { emoji_id: emojiId, emoji_name: emojiName, name, sound, volume };
+
+    const soundboardSound = await (this as any).client.rest.post(Routes.guildSoundboardSounds(this.guild.id), {
+      body,
+      reason,
+    });
+
+    return this._add(soundboardSound, true);
+  }
+
+  /**
+   * Edits a soundboard sound.
+   *
+   * @param {any} soundboardSound The soundboard sound to edit
+   * @param {any} [options={}] The new data for the soundboard sound
+   * @returns {Promise<SoundboardSound>}
+   */
+  async edit(soundboardSound: any, options: any = {}): Promise<any> {
+    const soundId = this.resolveId(soundboardSound);
+
+    if (!soundId) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'soundboardSound', 'SoundboardSoundResolvable');
+
+    const { emojiId, emojiName, name, reason, volume } = options;
+
+    const body = { emoji_id: emojiId, emoji_name: emojiName, name, volume };
+
+    const data = await (this as any).client.rest.patch(Routes.guildSoundboardSound(this.guild.id, soundId), {
+      body,
+      reason,
+    });
+
+    const existing = (this as any).cache.get(soundId);
+
+    if (existing) {
+      const clone = existing._clone();
+
+      clone._patch(data);
+      return clone;
+    }
+
+    return this._add(data, true);
+  }
+
+  /**
+   * Deletes a soundboard sound.
+   *
+   * @param {any} soundboardSound The soundboard sound to delete
+   * @param {string} [reason] Reason for deleting this soundboard sound
+   * @returns {Promise<void>}
+   */
+  async delete(soundboardSound: any, reason: string): Promise<void> {
+    const soundId = this.resolveId(soundboardSound);
+
+    if (!soundId) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'soundboardSound', 'SoundboardSoundResolvable');
+
+    await (this as any).client.rest.delete(Routes.guildSoundboardSound(this.guild.id, soundId), { reason });
+  }
+
+  /**
+   * Obtains one or more soundboard sounds from Discord, or the soundboard sound cache if they're already available.
+   *
+   * @param {any} [options] Options for fetching soundboard sound(s)
+   * @returns {Promise<any>}
+   */
+  async fetch(options: any): Promise<any> {
+    if (!options) return this._fetchMany();
+    const { cache, force, soundboardSound } = options;
+    const resolvedSoundboardSound = this.resolveId(soundboardSound ?? options);
+    if (resolvedSoundboardSound) return this._fetchSingle({ cache, force, soundboardSound: resolvedSoundboardSound });
+    return this._fetchMany({ cache });
+  }
+
+  async _fetchSingle({ cache, force, soundboardSound }: any = {}): Promise<any> {
+    if (!force) {
+      const existing = (this as any).cache.get(soundboardSound);
+      if (existing) return existing;
+    }
+
+    const data = await (this as any).client.rest.get(Routes.guildSoundboardSound(this.guild.id, soundboardSound));
+    return this._add(data, cache);
+  }
+
+  async _fetchMany({ cache }: any = {}): Promise<any> {
+    const data = await (this as any).client.rest.get(Routes.guildSoundboardSounds(this.guild.id));
+
+    return (data as any).items.reduce((coll: any, sound: any) => coll.set(sound.sound_id, this._add(sound, cache)), new (this as any).client.options.makeCache());
+  }
+}

package/src/managers/GuildStickerManager.ts

@@ -0,0 +1,192 @@
+import { Collection  } from '@ovencord/collection';
+import { Routes  } from 'discord-api-types/v10';
+import { DiscordjsTypeError, ErrorCodes  } from '../errors/index.js';
+import { MessagePayload  } from '../structures/MessagePayload.js';
+import { Sticker  } from '../structures/Sticker.js';
+import { CachedManager  } from './CachedManager.js';
+
+/**
+ * Manages API methods for Guild Stickers and stores their cache.
+ *
+ * @extends {CachedManager}
+ */
+export class GuildStickerManager extends CachedManager {
+  public guild: any;
+  constructor(guild, iterable) {
+    super(guild.client, Sticker, iterable);
+
+    /**
+     * The guild this manager belongs to
+     *
+     * @type {Guild}
+     */
+    this.guild = guild;
+  }
+
+  /**
+   * The cache of Guild Stickers
+   *
+   * @type {Collection<Snowflake, Sticker>}
+   * @name GuildStickerManager#cache
+   */
+
+  _add(data, cache) {
+    return super._add(data, cache, { extras: [this.guild] });
+  }
+
+  /**
+   * Options used to create a guild sticker.
+   *
+   * @typedef {Object} GuildStickerCreateOptions
+   * @property {AttachmentPayload|BufferResolvable|Stream} file The file for the sticker
+   * @property {string} name The name for the sticker
+   * @property {string} tags The Discord name of a unicode emoji representing the sticker's expression
+   * @property {?string} [description] The description for the sticker
+   * @property {string} [reason] Reason for creating the sticker
+   */
+
+  /**
+   * Creates a new custom sticker in the guild.
+   *
+   * @param {GuildStickerCreateOptions} options Options for creating a guild sticker
+   * @returns {Promise<Sticker>} The created sticker
+   * @example
+   * // Create a new sticker from a URL
+   * guild.stickers.create({ file: 'https://i.imgur.com/w3duR07.png', name: 'rip', tags: 'headstone' })
+   *   .then(sticker => console.log(`Created new sticker with name ${sticker.name}!`))
+   *   .catch(console.error);
+   * @example
+   * // Create a new sticker from a file on your computer
+   * guild.stickers.create({ file: './memes/banana.png', name: 'banana', tags: 'banana' })
+   *   .then(sticker => console.log(`Created new sticker with name ${sticker.name}!`))
+   *   .catch(console.error);
+   */
+  async create({ file, name, tags, description, reason } = {}) {
+    const resolvedFile = await MessagePayload.resolveFile(file);
+    resolvedFile.key = 'file';
+
+    const body = { name, tags, description: description ?? '' };
+
+    const sticker = await this.client.rest.post(Routes.guildStickers(this.guild.id), {
+      appendToFormData: true,
+      body,
+      files: [resolvedFile],
+      reason,
+    });
+    return this.client.actions.GuildStickerCreate.handle(this.guild, sticker).sticker;
+  }
+
+  /**
+   * Data that resolves to give a Sticker object. This can be:
+   * - A Sticker object
+   * - A Snowflake
+   *
+   * @typedef {Sticker|Snowflake} StickerResolvable
+   */
+
+  /**
+   * Resolves a StickerResolvable to a Sticker object.
+   *
+   * @method resolve
+   * @memberof GuildStickerManager
+   * @instance
+   * @param {StickerResolvable} sticker The Sticker resolvable to identify
+   * @returns {?Sticker}
+   */
+
+  /**
+   * Resolves a StickerResolvable to a Sticker id string.
+   *
+   * @method resolveId
+   * @memberof GuildStickerManager
+   * @instance
+   * @param {StickerResolvable} sticker The Sticker resolvable to identify
+   * @returns {?Snowflake}
+   */
+
+  /**
+   * Edits a sticker.
+   *
+   * @param {StickerResolvable} sticker The sticker to edit
+   * @param {GuildStickerEditOptions} [options={}] The new data for the sticker
+   * @returns {Promise<Sticker>}
+   */
+  async edit(sticker, options = {}) {
+    const stickerId = this.resolveId(sticker);
+    if (!stickerId) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'sticker', 'StickerResolvable');
+
+    const data = await this.client.rest.patch(Routes.guildSticker(this.guild.id, stickerId), {
+      body: options,
+      reason: options.reason,
+    });
+
+    const existing = this.cache.get(stickerId);
+    if (existing) {
+      const clone = existing._clone();
+      clone._patch(data);
+      return clone;
+    }
+
+    return this._add(data);
+  }
+
+  /**
+   * Deletes a sticker.
+   *
+   * @param {StickerResolvable} sticker The sticker to delete
+   * @param {string} [reason] Reason for deleting this sticker
+   * @returns {Promise<void>}
+   */
+  async delete(sticker, reason) {
+    const resolvedStickerId = this.resolveId(sticker);
+    if (!resolvedStickerId) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'sticker', 'StickerResolvable');
+
+    await this.client.rest.delete(Routes.guildSticker(this.guild.id, resolvedStickerId), { reason });
+  }
+
+  /**
+   * Obtains one or more stickers from Discord, or the sticker cache if they're already available.
+   *
+   * @param {Snowflake} [id] The Sticker's id
+   * @param {BaseFetchOptions} [options] Additional options for this fetch
+   * @returns {Promise<Sticker|Collection<Snowflake, Sticker>>}
+   * @example
+   * // Fetch all stickers from the guild
+   * message.guild.stickers.fetch()
+   *   .then(stickers => console.log(`There are ${stickers.size} stickers.`))
+   *   .catch(console.error);
+   * @example
+   * // Fetch a single sticker
+   * message.guild.stickers.fetch('222078108977594368')
+   *   .then(sticker => console.log(`The sticker name is: ${sticker.name}`))
+   *   .catch(console.error);
+   */
+  async fetch(id, { cache = true, force = false } = {}) {
+    if (id) {
+      if (!force) {
+        const existing = this.cache.get(id);
+        if (existing) return existing;
+      }
+
+      const sticker = await this.client.rest.get(Routes.guildSticker(this.guild.id, id));
+      return this._add(sticker, cache);
+    }
+
+    const data = await this.client.rest.get(Routes.guildStickers(this.guild.id));
+    return new Collection(data.map(sticker => [sticker.id, this._add(sticker, cache)]));
+  }
+
+  /**
+   * Fetches the user who uploaded this sticker, if this is a guild sticker.
+   *
+   * @param {StickerResolvable} sticker The sticker to fetch the user for
+   * @returns {Promise<?User>}
+   */
+  async fetchUser(sticker) {
+    const resolvedSticker = this.resolve(sticker);
+    if (!resolvedSticker) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'sticker', 'StickerResolvable');
+    const data = await this.client.rest.get(Routes.guildSticker(this.guild.id, resolvedSticker.id));
+    resolvedSticker._patch(data);
+    return resolvedSticker.user;
+  }
+}

package/src/managers/GuildTextThreadManager.ts

@@ -0,0 +1,91 @@
+import { ChannelType, Routes  } from 'discord-api-types/v10';
+import { DiscordjsTypeError, ErrorCodes  } from '../errors/index.js';
+import { ThreadManager  } from './ThreadManager.js';
+
+/**
+ * Manages API methods for {@link ThreadChannel} objects and stores their cache.
+ *
+ * @extends {ThreadManager}
+ */
+export class GuildTextThreadManager extends ThreadManager {
+  /**
+   * The channel this Manager belongs to
+   *
+   * @name GuildTextThreadManager#channel
+   * @type {TextChannel|AnnouncementChannel}
+   */
+
+  /**
+   * Options for creating a thread. <warn>Only one of `startMessage` or `type` can be defined.</warn>
+   *
+   * @typedef {StartThreadOptions} GuildTextThreadCreateOptions
+   * @property {MessageResolvable} [startMessage] The message to start a thread from.
+   * <warn>If this is defined, then the `type` of thread gets inferred automatically and cannot be changed.</warn>
+   * @property {ThreadChannelTypes} [type] The type of thread to create.
+   * Defaults to {@link ChannelType.PublicThread} if created in a {@link TextChannel}
+   * <warn>When creating threads in a {@link AnnouncementChannel}, this is ignored and is always
+   * {@link ChannelType.AnnouncementThread}</warn>
+   * @property {boolean} [invitable] Whether non-moderators can add other non-moderators to the thread
+   * <info>Can only be set when type will be {@link ChannelType.PrivateThread}</info>
+   */
+
+  /**
+   * Creates a new thread in the channel.
+   *
+   * @param {GuildTextThreadCreateOptions} [options] Options to create a new thread
+   * @returns {Promise<ThreadChannel>}
+   * @example
+   * // Create a new public thread
+   * channel.threads
+   *   .create({
+   *     name: 'food-talk',
+   *     autoArchiveDuration: ThreadAutoArchiveDuration.OneHour,
+   *     reason: 'Needed a separate thread for food',
+   *   })
+   *   .then(threadChannel => console.log(threadChannel))
+   *   .catch(console.error);
+   * @example
+   * // Create a new private thread
+   * channel.threads
+   *   .create({
+   *      name: 'mod-talk',
+   *      autoArchiveDuration: ThreadAutoArchiveDuration.OneHour,
+   *      type: ChannelType.PrivateThread,
+   *      reason: 'Needed a separate thread for moderation',
+   *    })
+   *   .then(threadChannel => console.log(threadChannel))
+   *   .catch(console.error);
+   */
+  async create({
+    name,
+    autoArchiveDuration = this.channel.defaultAutoArchiveDuration,
+    startMessage,
+    type,
+    invitable,
+    reason,
+    rateLimitPerUser,
+  } = {}) {
+    let resolvedType =
+      this.channel.type === ChannelType.GuildAnnouncement ? ChannelType.AnnouncementThread : ChannelType.PublicThread;
+    let startMessageId;
+    if (startMessage) {
+      startMessageId = this.channel.messages.resolveId(startMessage);
+      if (!startMessageId) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'startMessage', 'MessageResolvable');
+    } else if (this.channel.type !== ChannelType.GuildAnnouncement) {
+      resolvedType = type ?? resolvedType;
+    }
+
+    const data = await this.client.rest.post(Routes.threads(this.channel.id, startMessageId), {
+      body: {
+        name,
+        auto_archive_duration: autoArchiveDuration,
+        type: resolvedType,
+        invitable: resolvedType === ChannelType.PrivateThread ? invitable : undefined,
+        rate_limit_per_user: rateLimitPerUser,
+      },
+      reason,
+    });
+
+    return this.client.actions.ThreadCreate.handle(data).thread;
+  }
+}