@ovencord/discord.js 14.16.3

package/src/managers/GuildEmojiManager.ts

@@ -0,0 +1,262 @@
+import { Collection  } from '@ovencord/collection';
+import { Routes, PermissionFlagsBits  } from 'discord-api-types/v10';
+import { DiscordjsError, DiscordjsTypeError, ErrorCodes  } from '../errors/index.js';
+import { ApplicationEmoji  } from '../structures/ApplicationEmoji.js';
+import { GuildEmoji  } from '../structures/GuildEmoji.js';
+import { ReactionEmoji  } from '../structures/ReactionEmoji.js';
+import { resolveImage  } from '../util/DataResolver.js';
+import { parseEmoji  } from '../util/Util.js';
+import { CachedManager  } from './CachedManager.js';
+
+/**
+ * Manages API methods for GuildEmojis and stores their cache.
+ *
+ * @extends {CachedManager}
+ */
+export class GuildEmojiManager extends CachedManager {
+  public guild: any;
+  constructor(guild, iterable) {
+    super(guild.client, GuildEmoji, iterable);
+
+    /**
+     * The guild this manager belongs to
+     *
+     * @type {Guild}
+     */
+    this.guild = guild;
+  }
+
+  _add(data, cache) {
+    return super._add(data, cache, { extras: [this.guild] });
+  }
+
+  /**
+   * The cache of GuildEmojis
+   *
+   * @type {Collection<Snowflake, GuildEmoji>}
+   * @name GuildEmojiManager#cache
+   */
+
+  /**
+   * Data that can be resolved into a GuildEmoji object. This can be:
+   * - A Snowflake
+   * - A GuildEmoji object
+   * - A ReactionEmoji object
+   * - An ApplicationEmoji object
+   *
+   * @typedef {Snowflake|GuildEmoji|ReactionEmoji|ApplicationEmoji} EmojiResolvable
+   */
+
+  /**
+   * Resolves an EmojiResolvable to an Emoji object.
+   *
+   * @param {EmojiResolvable} emoji The Emoji resolvable to identify
+   * @returns {?GuildEmoji}
+   */
+  resolve(emoji) {
+    if (emoji instanceof ReactionEmoji) return super.cache.get(emoji.id) ?? null;
+    if (emoji instanceof ApplicationEmoji) return super.cache.get(emoji.id) ?? null;
+    return super.resolve(emoji);
+  }
+
+  /**
+   * Resolves an EmojiResolvable to an Emoji id string.
+   *
+   * @param {EmojiResolvable} emoji The Emoji resolvable to identify
+   * @returns {?Snowflake}
+   */
+  resolveId(emoji) {
+    if (emoji instanceof ReactionEmoji) return emoji.id;
+    if (emoji instanceof ApplicationEmoji) return emoji.id;
+    return super.resolveId(emoji);
+  }
+
+  /**
+   * Data that can be resolved to give an emoji identifier. This can be:
+   * - An EmojiResolvable
+   * - The `<a:name:id>`, `<:name:id>`, `a:name:id` or `name:id` emoji identifier string of an emoji
+   * - The Unicode representation of an emoji
+   *
+   * @typedef {string|EmojiResolvable} EmojiIdentifierResolvable
+   */
+
+  /**
+   * Resolves an EmojiResolvable to an emoji identifier.
+   *
+   * @param {EmojiIdentifierResolvable} emoji The emoji resolvable to resolve
+   * @returns {?string}
+   */
+  resolveIdentifier(emoji) {
+    const emojiResolvable = this.resolve(emoji);
+    if (emojiResolvable) return emojiResolvable.identifier;
+    if (emoji instanceof ReactionEmoji) return emoji.identifier;
+    if (emoji instanceof ApplicationEmoji) return emoji.identifier;
+    if (typeof emoji === 'string') {
+      const res = parseEmoji(emoji);
+      let identifier = emoji;
+      if (res?.name.length) {
+        identifier = `${res.animated ? 'a:' : ''}${res.name}${res.id ? `:${res.id}` : ''}`;
+      }
+
+      if (!identifier.includes('%')) return encodeURIComponent(identifier);
+      return identifier;
+    }
+
+    return null;
+  }
+
+  /**
+   * Options used for creating an emoji in a guild.
+   *
+   * @typedef {Object} GuildEmojiCreateOptions
+   * @property {BufferResolvable|Base64Resolvable} attachment The image for the emoji
+   * @property {string} name The name for the emoji
+   * @property {Collection<Snowflake, Role>|RoleResolvable[]} [roles] The roles to limit the emoji to
+   * @property {string} [reason] The reason for creating the emoji
+   */
+
+  /**
+   * Creates a new custom emoji in the guild.
+   *
+   * @param {GuildEmojiCreateOptions} options Options for creating the emoji
+   * @returns {Promise<Emoji>} The created emoji
+   * @example
+   * // Create a new emoji from a URL
+   * guild.emojis.create({ attachment: 'https://i.imgur.com/w3duR07.png', name: 'rip' })
+   *   .then(emoji => console.log(`Created new emoji with name ${emoji.name}!`))
+   *   .catch(console.error);
+   * @example
+   * // Create a new emoji from a file on your computer
+   * guild.emojis.create({ attachment: './memes/banana.png', name: 'banana' })
+   *   .then(emoji => console.log(`Created new emoji with name ${emoji.name}!`))
+   *   .catch(console.error);
+   */
+  async create({ attachment, name, roles, reason }) {
+    const image = await resolveImage(attachment);
+    if (!image) throw new DiscordjsTypeError(ErrorCodes.ReqResourceType);
+
+    const body = { image, name };
+    if (roles) {
+      if (!Array.isArray(roles) && !(roles instanceof Collection)) {
+        throw new DiscordjsTypeError(
+          ErrorCodes.InvalidType,
+          'options.roles',
+          'Array or Collection of Roles or Snowflakes',
+          true,
+        );
+      }
+
+      body.roles = [];
+      for (const role of roles.values()) {
+        const resolvedRole = this.guild.roles.resolveId(role);
+        if (!resolvedRole) {
+          throw new DiscordjsTypeError(ErrorCodes.InvalidElement, 'Array or Collection', 'options.roles', role);
+        }
+
+        body.roles.push(resolvedRole);
+      }
+    }
+
+    const emoji = await this.client.rest.post(Routes.guildEmojis(this.guild.id), { body, reason });
+    return this.client.actions.GuildEmojiCreate.handle(this.guild, emoji).emoji;
+  }
+
+  /**
+   * Obtains one or more emojis from Discord, or the emoji cache if they're already available.
+   *
+   * @param {Snowflake} [id] The emoji's id
+   * @param {BaseFetchOptions} [options] Additional options for this fetch
+   * @returns {Promise<GuildEmoji|Collection<Snowflake, GuildEmoji>>}
+   * @example
+   * // Fetch all emojis from the guild
+   * message.guild.emojis.fetch()
+   *   .then(emojis => console.log(`There are ${emojis.size} emojis.`))
+   *   .catch(console.error);
+   * @example
+   * // Fetch a single emoji
+   * message.guild.emojis.fetch('222078108977594368')
+   *   .then(emoji => console.log(`The emoji name is: ${emoji.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 emoji = await this.client.rest.get(Routes.guildEmoji(this.guild.id, id));
+      return this._add(emoji, cache);
+    }
+
+    const data = await this.client.rest.get(Routes.guildEmojis(this.guild.id));
+    const emojis = new Collection();
+    for (const emoji of data) emojis.set(emoji.id, this._add(emoji, cache));
+    return emojis;
+  }
+
+  /**
+   * Deletes an emoji.
+   *
+   * @param {EmojiResolvable} emoji The Emoji resolvable to delete
+   * @param {string} [reason] Reason for deleting the emoji
+   * @returns {Promise<void>}
+   */
+  async delete(emoji, reason) {
+    const id = this.resolveId(emoji);
+    if (!id) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'emoji', 'EmojiResolvable', true);
+    await this.client.rest.delete(Routes.guildEmoji(this.guild.id, id), { reason });
+  }
+
+  /**
+   * Edits an emoji.
+   *
+   * @param {EmojiResolvable} emoji The Emoji resolvable to edit
+   * @param {GuildEmojiEditOptions} options The options to provide
+   * @returns {Promise<GuildEmoji>}
+   */
+  async edit(emoji, options) {
+    const id = this.resolveId(emoji);
+    if (!id) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'emoji', 'EmojiResolvable', true);
+    const roles = options.roles?.map(role => this.guild.roles.resolveId(role));
+    const newData = await this.client.rest.patch(Routes.guildEmoji(this.guild.id, id), {
+      body: {
+        name: options.name,
+        roles,
+      },
+      reason: options.reason,
+    });
+    const existing = this.cache.get(id);
+    if (existing) {
+      const clone = existing._clone();
+      clone._patch(newData);
+      return clone;
+    }
+
+    return this._add(newData);
+  }
+
+  /**
+   * Fetches the author for this emoji
+   *
+   * @param {EmojiResolvable} emoji The emoji to fetch the author of
+   * @returns {Promise<User>}
+   */
+  async fetchAuthor(emoji) {
+    const resolvedEmoji = this.resolve(emoji);
+    if (!resolvedEmoji) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'emoji', 'EmojiResolvable', true);
+    if (resolvedEmoji.managed) {
+      throw new DiscordjsError(ErrorCodes.EmojiManaged);
+    }
+
+    const { me } = this.guild.members;
+    if (!me) throw new DiscordjsError(ErrorCodes.GuildUncachedMe);
+    if (!me.permissions.any(PermissionFlagsBits.CreateGuildExpressions | PermissionFlagsBits.ManageGuildExpressions)) {
+      throw new DiscordjsError(ErrorCodes.MissingGuildExpressionsPermission, this.guild);
+    }
+
+    const data = await this.client.rest.get(Routes.guildEmoji(this.guild.id, resolvedEmoji.id));
+    resolvedEmoji._patch(data);
+    return resolvedEmoji.author;
+  }
+}

package/src/managers/GuildEmojiRoleManager.ts

@@ -0,0 +1,134 @@
+import { Collection  } from '@ovencord/collection';
+import { DiscordjsTypeError, ErrorCodes  } from '../errors/index.js';
+import { Role  } from '../structures/Role.js';
+import { DataManager  } from './DataManager.js';
+
+/**
+ * Manages API methods for roles belonging to emojis and stores their cache.
+ *
+ * @extends {DataManager}
+ */
+export class GuildEmojiRoleManager extends DataManager {
+  public emoji: any;
+  public guild: any;
+  constructor(emoji) {
+    super(emoji.client, Role);
+
+    /**
+     * The emoji belonging to this manager
+     *
+     * @type {GuildEmoji}
+     */
+    this.emoji = emoji;
+    /**
+     * The guild belonging to this manager
+     *
+     * @type {Guild}
+     */
+    this.guild = emoji.guild;
+  }
+
+  /**
+   * The cache of roles belonging to this emoji
+   *
+   * @type {Collection<Snowflake, Role>}
+   * @readonly
+   */
+  get cache() {
+    const cache = new Collection();
+    for (const roleId of this.emoji._roles) {
+      const role = this.guild.roles.cache.get(roleId);
+      if (role !== undefined) {
+        cache.set(roleId, role);
+      }
+    }
+
+    return cache;
+  }
+
+  /**
+   * Adds a role (or multiple roles) to the list of roles that can use this emoji.
+   *
+   * @param {RoleResolvable|RoleResolvable[]|Collection<Snowflake, Role>} roleOrRoles The role or roles to add
+   * @returns {Promise<GuildEmoji>}
+   */
+  async add(roleOrRoles) {
+    const roles = Array.isArray(roleOrRoles) || roleOrRoles instanceof Collection ? roleOrRoles : [roleOrRoles];
+
+    const resolvedRoleIds = [];
+    for (const role of roles.values()) {
+      const roleId = this.guild.roles.resolveId(role);
+      if (!roleId) {
+        throw new DiscordjsTypeError(ErrorCodes.InvalidElement, 'Array or Collection', 'roles', role);
+      }
+
+      resolvedRoleIds.push(roleId);
+    }
+
+    const newRoles = [...new Set(resolvedRoleIds.concat(...this.cache.keys()))];
+    return this.set(newRoles);
+  }
+
+  /**
+   * Removes a role (or multiple roles) from the list of roles that can use this emoji.
+   *
+   * @param {RoleResolvable|RoleResolvable[]|Collection<Snowflake, Role>} roleOrRoles The role or roles to remove
+   * @returns {Promise<GuildEmoji>}
+   */
+  async remove(roleOrRoles) {
+    const roles = Array.isArray(roleOrRoles) || roleOrRoles instanceof Collection ? roleOrRoles : [roleOrRoles];
+
+    const resolvedRoleIds = [];
+    for (const role of roles.values()) {
+      const roleId = this.guild.roles.resolveId(role);
+      if (!roleId) {
+        throw new DiscordjsTypeError(ErrorCodes.InvalidElement, 'Array or Collection', 'roles', role);
+      }
+
+      resolvedRoleIds.push(roleId);
+    }
+
+    const newRoles = [...this.cache.keys()].filter(id => !resolvedRoleIds.includes(id));
+    return this.set(newRoles);
+  }
+
+  /**
+   * Sets the role(s) that can use this emoji.
+   *
+   * @param {Collection<Snowflake, Role>|RoleResolvable[]} roles The roles or role ids to apply
+   * @returns {Promise<GuildEmoji>}
+   * @example
+   * // Set the emoji's roles to a single role
+   * guildEmoji.roles.set(['391156570408615936'])
+   *   .then(console.log)
+   *   .catch(console.error);
+   * @example
+   * // Remove all roles from an emoji
+   * guildEmoji.roles.set([])
+   *    .then(console.log)
+   *    .catch(console.error);
+   */
+  async set(roles) {
+    return this.emoji.edit({ roles });
+  }
+
+  clone() {
+    const clone = new this.constructor(this.emoji);
+    clone._patch([...this.cache.keys()]);
+    return clone;
+  }
+
+  /**
+   * Patches the roles for this manager's cache
+   *
+   * @param {Snowflake[]} roles The new roles
+   * @private
+   */
+  _patch(roles) {
+    this.emoji._roles = roles;
+  }
+
+  valueOf() {
+    return this.cache;
+  }
+}

package/src/managers/GuildForumThreadManager.ts

@@ -0,0 +1,84 @@
+import { Routes  } from 'discord-api-types/v10';
+import { DiscordjsTypeError, ErrorCodes  } from '../errors/index.js';
+import { MessagePayload  } from '../structures/MessagePayload.js';
+import { ThreadManager  } from './ThreadManager.js';
+
+/**
+ * Manages API methods for threads in forum channels and stores their cache.
+ *
+ * @extends {ThreadManager}
+ */
+export class GuildForumThreadManager extends ThreadManager {
+  /**
+   * The channel this Manager belongs to
+   *
+   * @name GuildForumThreadManager#channel
+   * @type {ForumChannel}
+   */
+
+  /**
+   * @typedef {BaseMessageOptions} GuildForumThreadMessageCreateOptions
+   * @property {StickerResolvable} [stickers] The stickers to send with the message
+   * @property {BitFieldResolvable} [flags] The flags to send with the message
+   * <info>Only {@link MessageFlags.SuppressEmbeds}, {@link MessageFlags.SuppressNotifications}, and
+   * {@link MessageFlags.IsVoiceMessage} can be set.</info>
+   */
+
+  /**
+   * Options for creating a thread.
+   *
+   * @typedef {StartThreadOptions} GuildForumThreadCreateOptions
+   * @property {GuildForumThreadMessageCreateOptions|MessagePayload} message The message associated with the thread post
+   * @property {Snowflake[]} [appliedTags] The tags to apply to the thread
+   */
+
+  /**
+   * Creates a new thread in the channel.
+   *
+   * @param {GuildForumThreadCreateOptions} [options] Options to create a new thread
+   * @returns {Promise<ThreadChannel>}
+   * @example
+   * // Create a new forum post
+   * forum.threads
+   *   .create({
+   *     name: 'Food Talk',
+   *     autoArchiveDuration: ThreadAutoArchiveDuration.OneHour,
+   *     message: {
+   *      content: 'Discuss your favorite food!',
+   *     },
+   *     reason: 'Needed a separate thread for food',
+   *   })
+   *   .then(threadChannel => console.log(threadChannel))
+   *   .catch(console.error);
+   */
+  async create({
+    name,
+    autoArchiveDuration = this.channel.defaultAutoArchiveDuration,
+    message,
+    reason,
+    rateLimitPerUser,
+    appliedTags,
+  } = {}) {
+    if (!message) {
+      throw new DiscordjsTypeError(ErrorCodes.GuildForumMessageRequired);
+    }
+
+    const { body, files } = await (message instanceof MessagePayload ? message : MessagePayload.create(this, message))
+      .resolveBody()
+      .resolveFiles();
+
+    const data = await this.client.rest.post(Routes.threads(this.channel.id), {
+      body: {
+        name,
+        auto_archive_duration: autoArchiveDuration,
+        rate_limit_per_user: rateLimitPerUser,
+        applied_tags: appliedTags,
+        message: body,
+      },
+      files,
+      reason,
+    });
+
+    return this.client.actions.ThreadCreate.handle(data).thread;
+  }
+}