@fluxerjs/core 1.0.8 → 1.1.0

package/dist/chunk-QEXIYXXU.mjs

@@ -0,0 +1,62 @@
+import {
+  Base
+} from "./chunk-XNS4O6QJ.mjs";
+
+// src/structures/Invite.ts
+import { Routes } from "@fluxerjs/types";
+var Invite = class extends Base {
+  client;
+  code;
+  type;
+  guild;
+  channel;
+  inviter;
+  memberCount;
+  presenceCount;
+  expiresAt;
+  temporary;
+  createdAt;
+  uses;
+  maxUses;
+  maxAge;
+  /** @param data - API invite from GET /invites/{code}, channel/guild invite list, or gateway INVITE_CREATE */
+  constructor(client, data) {
+    super();
+    this.client = client;
+    this.code = data.code;
+    this.type = data.type;
+    this.guild = data.guild;
+    this.channel = data.channel;
+    this.inviter = data.inviter ? client.getOrCreateUser(data.inviter) : null;
+    this.memberCount = data.member_count ?? null;
+    this.presenceCount = data.presence_count ?? null;
+    this.expiresAt = data.expires_at ?? null;
+    this.temporary = data.temporary ?? null;
+    this.createdAt = data.created_at ?? null;
+    this.uses = data.uses ?? null;
+    this.maxUses = data.max_uses ?? null;
+    this.maxAge = data.max_age ?? null;
+  }
+  /** Full invite URL (https://fluxer.gg/{code} or instance-specific). */
+  get url() {
+    return `https://fluxer.gg/${this.code}`;
+  }
+  /**
+   * Resolve the guild from cache if available.
+   * @returns The guild, or null if not cached
+   */
+  getGuild() {
+    return this.guild?.id ? this.client.guilds.get(this.guild.id) ?? null : null;
+  }
+  /**
+   * Delete this invite.
+   * Requires Manage Guild or Create Instant Invite permission.
+   */
+  async delete() {
+    await this.client.rest.delete(Routes.invite(this.code), { auth: true });
+  }
+};
+
+export {
+  Invite
+};

package/dist/chunk-UXIF75BV.mjs

@@ -0,0 +1,36 @@
+import {
+  Base
+} from "./chunk-XNS4O6QJ.mjs";
+
+// src/structures/GuildBan.ts
+import { Routes } from "@fluxerjs/types";
+var GuildBan = class extends Base {
+  client;
+  guildId;
+  user;
+  reason;
+  /** ISO timestamp when a temporary ban expires. Null for permanent bans. */
+  expiresAt;
+  /** @param data - API ban from GET /guilds/{id}/bans or gateway GUILD_BAN_ADD */
+  constructor(client, data, guildId) {
+    super();
+    this.client = client;
+    this.guildId = data.guild_id ?? guildId;
+    this.user = client.getOrCreateUser(data.user);
+    this.reason = data.reason ?? null;
+    this.expiresAt = data.expires_at ?? null;
+  }
+  /**
+   * Remove this ban (unban the user).
+   * Requires Ban Members permission.
+   */
+  async unban() {
+    await this.client.rest.delete(Routes.guildBan(this.guildId, this.user.id), {
+      auth: true
+    });
+  }
+};
+
+export {
+  GuildBan
+};

package/dist/chunk-V7LPVPGH.mjs

@@ -0,0 +1,305 @@
+import {
+  Events
+} from "./chunk-AH7KYH2Z.mjs";
+import {
+  buildSendBody
+} from "./chunk-PM2IUGNR.mjs";
+import {
+  Base
+} from "./chunk-XNS4O6QJ.mjs";
+
+// src/structures/Message.ts
+import { Collection as Collection2 } from "@fluxerjs/collection";
+import { MessageType, Routes } from "@fluxerjs/types";
+import { EmbedBuilder } from "@fluxerjs/builders";
+
+// src/util/ReactionCollector.ts
+import { EventEmitter } from "events";
+import { Collection } from "@fluxerjs/collection";
+var ReactionCollector = class extends EventEmitter {
+  client;
+  messageId;
+  channelId;
+  options;
+  collected = new Collection();
+  _timeout = null;
+  _ended = false;
+  _listener;
+  constructor(client, messageId, channelId, options = {}) {
+    super();
+    this.client = client;
+    this.messageId = messageId;
+    this.channelId = channelId;
+    this.options = {
+      filter: options.filter ?? (() => true),
+      time: options.time ?? 0,
+      max: options.max ?? 0
+    };
+    this._listener = (reaction, user, _msgId, chId, _emoji, userId) => {
+      if (this._ended || reaction.messageId !== this.messageId || chId !== this.channelId) return;
+      if (!this.options.filter(reaction, user)) return;
+      const key = `${userId}:${reaction.emoji.id ?? reaction.emoji.name}`;
+      this.collected.set(key, { reaction, user });
+      this.emit("collect", reaction, user);
+      if (this.options.max > 0 && this.collected.size >= this.options.max) {
+        this.stop("limit");
+      }
+    };
+    this.client.on(Events.MessageReactionAdd, this._listener);
+    if (this.options.time > 0) {
+      this._timeout = setTimeout(() => this.stop("time"), this.options.time);
+    }
+  }
+  stop(reason = "user") {
+    if (this._ended) return;
+    this._ended = true;
+    this.client.off(Events.MessageReactionAdd, this._listener);
+    if (this._timeout) {
+      clearTimeout(this._timeout);
+      this._timeout = null;
+    }
+    this.emit("end", this.collected, reason);
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+};
+
+// src/structures/Message.ts
+var Message = class _Message extends Base {
+  client;
+  id;
+  channelId;
+  guildId;
+  author;
+  content;
+  createdAt;
+  editedAt;
+  pinned;
+  attachments;
+  type;
+  flags;
+  mentionEveryone;
+  tts;
+  embeds;
+  stickers;
+  reactions;
+  messageReference;
+  messageSnapshots;
+  call;
+  referencedMessage;
+  /** Webhook ID if this message was sent via webhook. Null otherwise. */
+  webhookId;
+  /** Users mentioned in this message. */
+  mentions;
+  /** Role IDs mentioned in this message. */
+  mentionRoles;
+  /** Client-side nonce for acknowledgment. Null if not provided. */
+  nonce;
+  /** Channel where this message was sent. Resolved from cache; null if not cached (e.g. DM channel not in cache). */
+  get channel() {
+    return this.client.channels.get(this.channelId) ?? null;
+  }
+  /** Guild where this message was sent. Resolved from cache; null for DMs or if not cached. */
+  get guild() {
+    return this.guildId ? this.client.guilds.get(this.guildId) ?? null : null;
+  }
+  /** @param data - API message from POST/PATCH /channels/{id}/messages or gateway MESSAGE_CREATE */
+  constructor(client, data) {
+    super();
+    this.client = client;
+    this.id = data.id;
+    this.channelId = data.channel_id;
+    this.guildId = data.guild_id ?? null;
+    this.author = client.getOrCreateUser(data.author);
+    this.content = data.content;
+    this.createdAt = new Date(data.timestamp);
+    this.editedAt = data.edited_timestamp ? new Date(data.edited_timestamp) : null;
+    this.pinned = data.pinned;
+    this.attachments = new Collection2();
+    for (const a of data.attachments ?? []) this.attachments.set(a.id, a);
+    this.type = data.type ?? MessageType.Default;
+    this.flags = data.flags ?? 0;
+    this.mentionEveryone = data.mention_everyone ?? false;
+    this.tts = data.tts ?? false;
+    this.embeds = data.embeds ?? [];
+    this.stickers = data.stickers ?? [];
+    this.reactions = data.reactions ?? [];
+    this.messageReference = data.message_reference ?? null;
+    this.messageSnapshots = data.message_snapshots ?? [];
+    this.call = data.call ?? null;
+    this.referencedMessage = data.referenced_message ? new _Message(client, data.referenced_message) : null;
+    this.webhookId = data.webhook_id ?? null;
+    this.mentions = (data.mentions ?? []).map((u) => client.getOrCreateUser(u));
+    this.mentionRoles = data.mention_roles ?? [];
+    this.nonce = data.nonce ?? null;
+  }
+  /**
+   * Send a message to this channel without replying. Use when you want a standalone message.
+   * @param options - Text content or object with content, embeds, and/or files
+   * @example
+   * await message.send('Pong!');
+   * await message.send({ embeds: [embed.toJSON()] });
+   * await message.send({ content: 'File', files: [{ name: 'data.txt', data }] });
+   */
+  async send(options) {
+    const opts = typeof options === "string" ? { content: options } : options;
+    const body = buildSendBody(options);
+    const postOptions = opts.files?.length ? { body, files: opts.files } : { body };
+    const data = await this.client.rest.post(Routes.channelMessages(this.channelId), postOptions);
+    return new _Message(this.client, data);
+  }
+  /**
+   * Send a message to a specific channel. Use for logging, forwarding, or sending to another channel in the guild.
+   * @param channelId - Snowflake of the target channel (e.g. log channel ID)
+   * @param options - Text content or object with content and/or embeds
+   * @example
+   * await message.sendTo(logChannelId, 'User ' + message.author.username + ' said: ' + message.content);
+   * await message.sendTo(announceChannelId, { embeds: [embed.toJSON()] });
+   */
+  async sendTo(channelId, options) {
+    return this.client.channels.send(channelId, options);
+  }
+  /**
+   * Reply to this message.
+   * @param options - Text content or object with content, embeds, and/or files
+   */
+  async reply(options) {
+    const opts = typeof options === "string" ? { content: options } : options;
+    const base = buildSendBody(options);
+    const body = {
+      ...base,
+      message_reference: {
+        channel_id: this.channelId,
+        message_id: this.id,
+        guild_id: this.guildId ?? void 0
+      }
+    };
+    const postOptions = opts.files?.length ? { body, files: opts.files } : { body };
+    const data = await this.client.rest.post(Routes.channelMessages(this.channelId), postOptions);
+    return new _Message(this.client, data);
+  }
+  /**
+   * Edit this message. Only the author (or admins) can edit.
+   * @param options - New content and/or embeds
+   */
+  async edit(options) {
+    const body = {};
+    if (options.content !== void 0) body.content = options.content;
+    if (options.embeds?.length) {
+      body.embeds = options.embeds.map((e) => e instanceof EmbedBuilder ? e.toJSON() : e);
+    }
+    const data = await this.client.rest.patch(Routes.channelMessage(this.channelId, this.id), {
+      body
+    });
+    return new _Message(this.client, data);
+  }
+  /**
+   * Create a reaction collector for this message.
+   * Collects reactions matching the filter until time expires or max is reached.
+   * @param options - Filter, time (ms), and max count
+   * @example
+   * const collector = message.createReactionCollector({ filter: (r, u) => u.id === userId, time: 10000 });
+   * collector.on('collect', (reaction, user) => console.log(user.username, 'reacted with', reaction.emoji.name));
+   * collector.on('end', (collected, reason) => { ... });
+   */
+  createReactionCollector(options) {
+    return new ReactionCollector(this.client, this.id, this.channelId, options);
+  }
+  /**
+   * Re-fetch this message from the API to get the latest content, embeds, reactions, etc.
+   * Use when you have a stale Message (e.g. from an old event or cache) and need fresh data.
+   * @returns The updated message
+   * @throws FluxerError with MESSAGE_NOT_FOUND if the message was deleted or does not exist
+   * @example
+   * const updated = await message.fetch();
+   * console.log('Latest content:', updated.content);
+   */
+  async fetch() {
+    return this.client.channels.fetchMessage(this.channelId, this.id);
+  }
+  /** Delete this message. */
+  async delete() {
+    await this.client.rest.delete(Routes.channelMessage(this.channelId, this.id));
+  }
+  /** Pin this message to the channel. Requires Manage Messages permission. */
+  async pin() {
+    await this.client.rest.put(Routes.channelPinMessage(this.channelId, this.id));
+    this.pinned = true;
+  }
+  /** Unpin this message from the channel. Requires Manage Messages permission. */
+  async unpin() {
+    await this.client.rest.delete(Routes.channelPinMessage(this.channelId, this.id));
+    this.pinned = false;
+  }
+  /**
+   * Format emoji for reaction API: unicode string or "name:id" for custom.
+   * For string resolution (e.g. :name:), use client.resolveEmoji; Message methods resolve automatically when guildId is available.
+   */
+  static formatEmoji(emoji) {
+    if (typeof emoji === "string") return emoji;
+    return `${emoji.name}:${emoji.id}`;
+  }
+  resolveEmojiForReaction(emoji) {
+    return this.client.resolveEmoji(emoji, this.guildId);
+  }
+  /**
+   * Add a reaction to this message (as the bot).
+   * @param emoji - Unicode emoji, custom `{ name, id }`, `:name:`, `name:id`, or `<:name:id>`
+   */
+  async react(emoji) {
+    const emojiStr = await this.resolveEmojiForReaction(emoji);
+    const route = `${Routes.channelMessageReaction(this.channelId, this.id, emojiStr)}/@me`;
+    await this.client.rest.put(route);
+  }
+  /**
+   * Remove the bot's reaction, or a specific user's reaction if userId is provided.
+   * @param emoji - Unicode emoji, custom `{ name, id }`, `:name:`, `name:id`, or `<:name:id>`
+   * @param userId - If provided, removes that user's reaction (requires moderator permissions)
+   */
+  async removeReaction(emoji, userId) {
+    const emojiStr = await this.resolveEmojiForReaction(emoji);
+    const route = `${Routes.channelMessageReaction(this.channelId, this.id, emojiStr)}/${userId ?? "@me"}`;
+    await this.client.rest.delete(route);
+  }
+  /**
+   * Remove all reactions from this message.
+   * Requires moderator permissions.
+   */
+  async removeAllReactions() {
+    await this.client.rest.delete(Routes.channelMessageReactions(this.channelId, this.id));
+  }
+  /**
+   * Remove all reactions of a specific emoji from this message.
+   * @param emoji - Unicode emoji, custom `{ name, id }`, `:name:`, `name:id`, or `<:name:id>`. Requires moderator permissions.
+   */
+  async removeReactionEmoji(emoji) {
+    const emojiStr = await this.resolveEmojiForReaction(emoji);
+    await this.client.rest.delete(Routes.channelMessageReaction(this.channelId, this.id, emojiStr));
+  }
+  /**
+   * Fetch users who reacted with the given emoji.
+   * @param emoji - Unicode emoji or custom `{ name, id }`
+   * @param options - limit (1–100), after (user ID for pagination)
+   * @returns Array of User objects
+   */
+  async fetchReactionUsers(emoji, options) {
+    const emojiStr = await this.resolveEmojiForReaction(emoji);
+    const params = new URLSearchParams();
+    if (options?.limit != null) params.set("limit", String(options.limit));
+    if (options?.after) params.set("after", options.after);
+    const qs = params.toString();
+    const route = Routes.channelMessageReaction(this.channelId, this.id, emojiStr) + (qs ? `?${qs}` : "");
+    const data = await this.client.rest.get(route);
+    const list = Array.isArray(data) ? data : data?.users ?? [];
+    return list.map((u) => this.client.getOrCreateUser(u));
+  }
+};
+
+export {
+  ReactionCollector,
+  Message
+};

package/dist/chunk-X6K3ZD62.mjs

@@ -0,0 +1,53 @@
+import {
+  CDN_URL
+} from "./chunk-HQMYRYMY.mjs";
+
+// src/util/cdn.ts
+function getExtension(hash, options) {
+  const ext = options?.extension ?? "png";
+  if (hash?.startsWith("a_")) return "gif";
+  return ext;
+}
+function appendSize(options) {
+  return options?.size ? `?size=${options.size}` : "";
+}
+function cdnAvatarURL(userId, avatarHash, options) {
+  if (!avatarHash) return null;
+  const ext = getExtension(avatarHash, options);
+  const size = appendSize(options);
+  return `${CDN_URL}/avatars/${userId}/${avatarHash}.${ext}${size}`;
+}
+function cdnDisplayAvatarURL(userId, avatarHash, options) {
+  return cdnAvatarURL(userId, avatarHash, options) ?? `${CDN_URL}/avatars/0/0.png`;
+}
+function cdnBannerURL(resourceId, bannerHash, options) {
+  if (!bannerHash) return null;
+  const ext = getExtension(bannerHash, options);
+  const size = appendSize(options);
+  return `${CDN_URL}/banners/${resourceId}/${bannerHash}.${ext}${size}`;
+}
+function cdnMemberAvatarURL(guildId, userId, avatarHash, options) {
+  if (!avatarHash) return null;
+  const ext = getExtension(avatarHash, options);
+  const size = appendSize(options);
+  return `${CDN_URL}/guilds/${guildId}/users/${userId}/avatars/${avatarHash}.${ext}${size}`;
+}
+function cdnMemberBannerURL(guildId, userId, bannerHash, options) {
+  if (!bannerHash) return null;
+  const ext = getExtension(bannerHash, options);
+  const size = appendSize(options);
+  return `${CDN_URL}/guilds/${guildId}/users/${userId}/banners/${bannerHash}.${ext}${size}`;
+}
+function cdnDefaultAvatarURL(discriminatorIndex) {
+  const index = discriminatorIndex != null ? discriminatorIndex % 5 : 0;
+  return `${CDN_URL}/avatars/0/${index}.png`;
+}
+
+export {
+  cdnAvatarURL,
+  cdnDisplayAvatarURL,
+  cdnBannerURL,
+  cdnMemberAvatarURL,
+  cdnMemberBannerURL,
+  cdnDefaultAvatarURL
+};