@fluxerjs/core 1.1.7 → 1.1.9

package/dist/chunk-24E6OQID.mjs

@@ -0,0 +1,193 @@
+import {
+  cdnMemberAvatarURL,
+  cdnMemberBannerURL
+} from "./chunk-G6F6VL4O.mjs";
+import {
+  Base
+} from "./chunk-XNS4O6QJ.mjs";
+
+// src/structures/GuildMember.ts
+import { PermissionFlagsMap } from "@fluxerjs/util";
+import { Routes } from "@fluxerjs/types";
+
+// src/util/permissions.ts
+import { OverwriteType } from "@fluxerjs/types";
+import { ALL_PERMISSIONS_BIGINT } from "@fluxerjs/util";
+function computePermissions(basePermissions, overwrites, memberRoles, memberId, isOwner) {
+  if (isOwner) return ALL_PERMISSIONS_BIGINT;
+  let perms = basePermissions;
+  for (const overwrite of overwrites ?? []) {
+    const applies = overwrite.type === OverwriteType.Role && memberRoles.includes(overwrite.id) || overwrite.type === OverwriteType.Member && overwrite.id === memberId;
+    if (!applies) continue;
+    const allow = BigInt(overwrite.allow || "0");
+    const deny = BigInt(overwrite.deny || "0");
+    perms = perms & ~deny | allow;
+  }
+  return perms;
+}
+function hasPermission(bitfield, permission) {
+  const Administrator = 1n << 3n;
+  if ((bitfield & Administrator) !== 0n) return true;
+  return (bitfield & permission) === permission;
+}
+
+// src/structures/GuildMember.ts
+var GuildMember = class extends Base {
+  client;
+  id;
+  user;
+  guild;
+  nick;
+  roles;
+  joinedAt;
+  communicationDisabledUntil;
+  mute;
+  deaf;
+  avatar;
+  banner;
+  accentColor;
+  profileFlags;
+  /** @param data - API guild member from GET /guilds/{id}/members or GET /guilds/{id}/members/{user_id} */
+  constructor(client, data, guild) {
+    super();
+    this.client = client;
+    this.user = client.getOrCreateUser(data.user);
+    this.id = data.user.id;
+    this.guild = guild;
+    this.nick = data.nick ?? null;
+    this.roles = data.roles ?? [];
+    this.joinedAt = new Date(data.joined_at);
+    this.communicationDisabledUntil = data.communication_disabled_until ? new Date(data.communication_disabled_until) : null;
+    this.mute = data.mute ?? false;
+    this.deaf = data.deaf ?? false;
+    this.avatar = data.avatar ?? null;
+    this.banner = data.banner ?? null;
+    this.accentColor = data.accent_color ?? null;
+    this.profileFlags = data.profile_flags ?? null;
+  }
+  /** Nickname, or global name, or username. */
+  get displayName() {
+    return this.nick ?? this.user.globalName ?? this.user.username;
+  }
+  /**
+   * Get the guild-specific avatar URL for this member.
+   * Returns null if the member has no guild avatar (use displayAvatarURL for fallback).
+   */
+  avatarURL(options) {
+    return cdnMemberAvatarURL(this.guild.id, this.id, this.avatar, options);
+  }
+  /**
+   * Get the avatar URL to display for this member.
+   * Uses guild-specific avatar if set, otherwise falls back to the user's avatar.
+   */
+  displayAvatarURL(options) {
+    return this.avatarURL(options) ?? this.user.displayAvatarURL(options);
+  }
+  /**
+   * Get the guild-specific banner URL for this member.
+   * Returns null if the member has no guild banner.
+   */
+  bannerURL(options) {
+    return cdnMemberBannerURL(this.guild.id, this.id, this.banner, options);
+  }
+  /**
+   * Add a role to this member.
+   * @param roleId - The role ID to add
+   * Requires Manage Roles permission.
+   */
+  async addRole(roleId) {
+    await this.client.rest.put(Routes.guildMemberRole(this.guild.id, this.id, roleId));
+  }
+  /**
+   * Remove a role from this member.
+   * @param roleId - The role ID to remove
+   * Requires Manage Roles permission.
+   */
+  async removeRole(roleId) {
+    await this.client.rest.delete(Routes.guildMemberRole(this.guild.id, this.id, roleId));
+  }
+  /**
+   * Edit this guild member. PATCH /guilds/{id}/members/{userId} or /members/@me for the bot.
+   * For @me: nick, avatar, banner, bio, pronouns, accent_color, profile_flags, mute, deaf,
+   * communication_disabled_until, timeout_reason, channel_id, connection_id.
+   * For other members: same plus roles (array of role IDs).
+   */
+  async edit(options) {
+    const isMe = this.client.user?.id === this.id;
+    const route = isMe ? `/guilds/${this.guild.id}/members/@me` : Routes.guildMember(this.guild.id, this.id);
+    const data = await this.client.rest.patch(route, {
+      body: options,
+      auth: true
+    });
+    this.nick = data.nick ?? this.nick;
+    if (data.roles) this.roles = data.roles;
+    if (data.communication_disabled_until != null) {
+      this.communicationDisabledUntil = data.communication_disabled_until ? new Date(data.communication_disabled_until) : null;
+    }
+    return this;
+  }
+  /**
+   * Get the member's guild-level permissions (from roles only, no channel overwrites).
+   * Use this for server-wide permission checks (e.g. ban, kick, manage roles).
+   * @returns Object with has(permission) to check specific permissions
+   * @example
+   * const perms = member.permissions;
+   * if (perms.has(PermissionFlags.BanMembers)) { ... }
+   */
+  get permissions() {
+    const base = this._computeBasePermissions();
+    const ownerId = this.guild.ownerId;
+    const isOwner = ownerId != null && ownerId !== "" && String(ownerId) === String(this.id);
+    const perms = computePermissions(base, [], [], this.id, isOwner);
+    return {
+      has(permission) {
+        const perm = typeof permission === "number" ? permission : PermissionFlagsMap[String(permission)];
+        if (perm === void 0) return false;
+        return hasPermission(perms, BigInt(perm));
+      }
+    };
+  }
+  /**
+   * Compute the member's effective permissions in a guild channel.
+   * Applies role permissions and channel overwrites.
+   * @param channel - The guild channel to check permissions for
+   * @returns Object with has(permission) to check specific permissions
+   * @example
+   * const perms = member.permissionsIn(channel);
+   * if (perms.has(PermissionFlags.SendMessages)) { ... }
+   */
+  permissionsIn(channel) {
+    const base = this._computeBasePermissions();
+    const ownerId = this.guild.ownerId;
+    const isOwner = ownerId != null && ownerId !== "" && String(ownerId) === String(this.id);
+    const perms = computePermissions(
+      base,
+      channel.permissionOverwrites,
+      this.roles,
+      this.id,
+      isOwner
+    );
+    return {
+      has(permission) {
+        const perm = typeof permission === "number" ? permission : PermissionFlagsMap[String(permission)];
+        if (perm === void 0) return false;
+        return hasPermission(perms, BigInt(perm));
+      }
+    };
+  }
+  _computeBasePermissions() {
+    let base = 0n;
+    const everyone = this.guild.roles.get(this.guild.id);
+    if (everyone) base |= BigInt(everyone.permissions);
+    for (const roleId of this.roles) {
+      if (roleId === this.guild.id) continue;
+      const role = this.guild.roles.get(roleId);
+      if (role) base |= BigInt(role.permissions);
+    }
+    return base;
+  }
+};
+
+export {
+  GuildMember
+};

package/dist/chunk-25Q2GMSK.mjs

@@ -0,0 +1,137 @@
+import {
+  CDN_URL
+} from "./chunk-HQMYRYMY.mjs";
+import {
+  Base
+} from "./chunk-XNS4O6QJ.mjs";
+
+// src/structures/User.ts
+import { Routes } from "@fluxerjs/types";
+var User = class extends Base {
+  client;
+  id;
+  username;
+  discriminator;
+  globalName;
+  avatar;
+  bot;
+  /** RGB avatar color (e.g. 7577782). Null if not set. */
+  avatarColor;
+  /** Public flags bitfield. Null if not set. */
+  flags;
+  /** Whether this is an official system user. */
+  system;
+  /** Banner hash (from profile, member, or invite context). Null when not available. */
+  banner;
+  /** @param data - API user from message author, GET /users/{id}, or GET /users/@me */
+  constructor(client, data) {
+    super();
+    this.client = client;
+    this.id = data.id;
+    this.username = data.username;
+    this.discriminator = data.discriminator;
+    this.globalName = data.global_name ?? null;
+    this.avatar = data.avatar ?? null;
+    this.bot = !!data.bot;
+    this.avatarColor = data.avatar_color ?? null;
+    this.flags = data.flags ?? data.public_flags ?? null;
+    this.system = !!data.system;
+    this.banner = data.banner ?? null;
+  }
+  /** Update mutable fields from fresh API data. Used by getOrCreateUser cache. */
+  _patch(data) {
+    this.username = data.username;
+    this.discriminator = data.discriminator;
+    this.globalName = data.global_name ?? null;
+    this.avatar = data.avatar ?? null;
+    if (data.avatar_color !== void 0) this.avatarColor = data.avatar_color;
+    if (data.flags !== void 0) this.flags = data.flags;
+    if (data.banner !== void 0) this.banner = data.banner;
+  }
+  /**
+   * Get the URL for this user's avatar.
+   * Auto-detects animated avatars (hash starting with `a_`) and uses gif extension.
+   * @param options - Optional `size` and `extension` (default: png, or gif for animated)
+   */
+  avatarURL(options) {
+    if (!this.avatar) return null;
+    const ext = this.avatar.startsWith("a_") ? "gif" : options?.extension ?? "png";
+    const size = options?.size ? `?size=${options.size}` : "";
+    return `${CDN_URL}/avatars/${this.id}/${this.avatar}.${ext}${size}`;
+  }
+  /** Get the avatar URL, or the default avatar if none set. */
+  displayAvatarURL(options) {
+    return this.avatarURL(options) ?? `${CDN_URL}/avatars/0/0.png`;
+  }
+  /**
+   * Get the URL for this user's banner.
+   * Returns null if the user has no banner (only available when fetched from profile/member context).
+   */
+  bannerURL(options) {
+    if (!this.banner) return null;
+    const ext = this.banner.startsWith("a_") ? "gif" : options?.extension ?? "png";
+    const size = options?.size ? `?size=${options.size}` : "";
+    return `${CDN_URL}/banners/${this.id}/${this.banner}.${ext}${size}`;
+  }
+  /** Returns a mention string (e.g. `<@123456>`). */
+  toString() {
+    return `<@${this.id}>`;
+  }
+  /**
+   * Create or get a DM channel with this user.
+   * Returns the DM channel; use {@link DMChannel.send} to send messages.
+   */
+  async createDM() {
+    const { DMChannel: DMChannelClass } = await import("./Channel-HK7VT35N.mjs");
+    const data = await this.client.rest.post(Routes.userMeChannels(), {
+      body: { recipient_id: this.id },
+      auth: true
+    });
+    return new DMChannelClass(this.client, data);
+  }
+  /**
+   * Send a DM to this user.
+   * Convenience method that creates the DM channel and sends the message.
+   */
+  async send(options) {
+    const dm = await this.createDM();
+    return dm.send(options);
+  }
+};
+
+// src/client/ClientUser.ts
+import { Routes as Routes2 } from "@fluxerjs/types";
+var ClientUser = class extends User {
+  constructor(client, data) {
+    super(client, { ...data });
+  }
+  /**
+   * Fetch guilds the bot is a member of.
+   * @returns Array of Guild objects (cached in client.guilds)
+   */
+  async fetchGuilds() {
+    const { Guild } = await import("./Guild-RPQGTXB7.mjs");
+    const data = await this.client.rest.get(Routes2.currentUserGuilds());
+    const list = Array.isArray(data) ? data : data?.guilds ?? [];
+    const guilds = [];
+    for (const g of list) {
+      const guild = new Guild(this.client, g);
+      this.client.guilds.set(guild.id, guild);
+      guilds.push(guild);
+    }
+    return guilds;
+  }
+  /**
+   * Leave a guild. Requires the bot to be a member.
+   * @param guildId - The guild ID to leave
+   */
+  async leaveGuild(guildId) {
+    await this.client.rest.delete(Routes2.leaveGuild(guildId), { auth: true });
+    this.client.guilds.delete(guildId);
+  }
+};
+
+export {
+  User,
+  ClientUser
+};

package/dist/chunk-26GCIGHL.mjs

@@ -0,0 +1,52 @@
+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;
+  /** @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;
+  }
+  /** 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-2CIZJCEO.mjs

@@ -0,0 +1,132 @@
+import {
+  buildSendBodyAsync
+} from "./chunk-OMFDQURC.mjs";
+import {
+  Base
+} from "./chunk-XNS4O6QJ.mjs";
+
+// src/structures/Webhook.ts
+import { Routes } from "@fluxerjs/types";
+var Webhook = class _Webhook extends Base {
+  client;
+  id;
+  guildId;
+  channelId;
+  name;
+  avatar;
+  /** Present only when webhook was created via createWebhook(); not returned when fetching. */
+  token;
+  /** User who created the webhook. */
+  user;
+  /** @param data - API webhook from POST /channels/{id}/webhooks (has token) or GET /webhooks/{id} (no token) */
+  constructor(client, data) {
+    super();
+    this.client = client;
+    this.id = data.id;
+    this.guildId = data.guild_id;
+    this.channelId = data.channel_id;
+    this.name = data.name ?? "Unknown";
+    this.avatar = data.avatar ?? null;
+    this.token = data.token ?? null;
+    this.user = client.getOrCreateUser(data.user);
+  }
+  /** Delete this webhook. Requires bot token with Manage Webhooks permission. */
+  async delete() {
+    await this.client.rest.delete(Routes.webhook(this.id), { auth: true });
+  }
+  /**
+   * Edit this webhook. With token: name and avatar only. Without token (bot auth): name, avatar, and channel_id.
+   * @param options - Fields to update (name, avatar, channel_id when using bot auth)
+   * @returns This webhook instance with updated fields
+   */
+  async edit(options) {
+    const body = {};
+    if (options.name !== void 0) body.name = options.name;
+    if (options.avatar !== void 0) body.avatar = options.avatar;
+    if ("channel_id" in options && options.channel_id !== void 0 && !this.token) {
+      body.channel_id = options.channel_id;
+    }
+    if (this.token) {
+      const data2 = await this.client.rest.patch(Routes.webhookExecute(this.id, this.token), {
+        body,
+        auth: false
+      });
+      const w2 = data2;
+      this.name = w2.name ?? this.name;
+      this.avatar = w2.avatar ?? null;
+      return this;
+    }
+    const data = await this.client.rest.patch(Routes.webhook(this.id), {
+      body,
+      auth: true
+    });
+    const w = data;
+    this.name = w.name ?? this.name;
+    this.avatar = w.avatar ?? null;
+    this.channelId = w.channel_id ?? this.channelId;
+    return this;
+  }
+  /**
+   * Send a message via this webhook. Requires the webhook token (only present when created, not when fetched).
+   * @param options - Text content or object with content, embeds, username, avatar_url, tts, files, attachments
+   * @param wait - If true, waits for the API and returns the created Message; otherwise returns void (204)
+   * @throws Error if token is not available
+   * @example
+   * await webhook.send('Hello!');
+   * await webhook.send({ embeds: [embed.toJSON()] });
+   * await webhook.send({ content: 'File attached', files: [{ name: 'data.txt', data: buffer }] });
+   * const msg = await webhook.send({ content: 'Hi' }, true);
+   */
+  async send(options, wait) {
+    if (!this.token) {
+      throw new Error(
+        "Webhook token is required to send. The token is only returned when creating a webhook; fetched webhooks cannot send."
+      );
+    }
+    const opts = typeof options === "string" ? { content: options } : options;
+    const body = await buildSendBodyAsync(options);
+    if (opts.username !== void 0) body.username = opts.username;
+    if (opts.avatar_url !== void 0) body.avatar_url = opts.avatar_url;
+    if (opts.tts !== void 0) body.tts = opts.tts;
+    const route = Routes.webhookExecute(this.id, this.token) + (wait ? "?wait=true" : "");
+    const postOptions = opts.files?.length ? { body, files: opts.files, auth: false } : { body, auth: false };
+    const data = await this.client.rest.post(route, postOptions);
+    if (wait && data) {
+      const { Message } = await import("./Message-E3WU3J2Q.mjs");
+      return new Message(this.client, data);
+    }
+    return void 0;
+  }
+  /**
+   * Fetch a webhook by ID using bot auth.
+   * @param client - The client instance
+   * @param webhookId - The webhook ID
+   * @returns Webhook without token (cannot send)
+   */
+  static async fetch(client, webhookId) {
+    const data = await client.rest.get(Routes.webhook(webhookId));
+    return new _Webhook(client, data);
+  }
+  /**
+   * Create a Webhook instance from an ID and token (e.g. from a stored webhook URL).
+   * @param client - The client instance
+   * @param webhookId - The webhook ID
+   * @param token - The webhook token (from createWebhook or stored)
+   * @param options - Optional channelId, guildId, name for display
+   */
+  static fromToken(client, webhookId, token, options) {
+    return new _Webhook(client, {
+      id: webhookId,
+      guild_id: options?.guildId ?? "",
+      channel_id: options?.channelId ?? "",
+      name: options?.name ?? "Webhook",
+      avatar: null,
+      token,
+      user: { id: "", username: "webhook", discriminator: "0" }
+    });
+  }
+};
+
+export {
+  Webhook
+};

package/dist/chunk-2FIZRRSO.mjs

@@ -0,0 +1,88 @@
+import {
+  User
+} from "./chunk-WZVY7DA6.mjs";
+import {
+  Base
+} from "./chunk-XNS4O6QJ.mjs";
+
+// src/structures/Message.ts
+import { Collection } from "@fluxerjs/collection";
+import { Routes } from "@fluxerjs/types";
+import { EmbedBuilder } from "@fluxerjs/builders";
+var Message = class _Message extends Base {
+  client;
+  id;
+  channelId;
+  guildId;
+  author;
+  content;
+  createdAt;
+  editedAt;
+  pinned;
+  attachments;
+  channel;
+  constructor(client, data) {
+    super();
+    this.client = client;
+    this.id = data.id;
+    this.channelId = data.channel_id;
+    this.guildId = data.guild_id ?? null;
+    this.author = new User(client, 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 Collection();
+    for (const a of data.attachments ?? []) this.attachments.set(a.id, a);
+  }
+  async reply(options) {
+    const body = typeof options === "string" ? { content: options, message_reference: { channel_id: this.channelId, message_id: this.id, guild_id: this.guildId ?? void 0 } } : { ...options, message_reference: { channel_id: this.channelId, message_id: this.id, guild_id: this.guildId ?? void 0 } };
+    const data = await this.client.rest.post(Routes.channelMessages(this.channelId), { body });
+    return new _Message(this.client, data);
+  }
+  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);
+  }
+  async delete() {
+    await this.client.rest.delete(Routes.channelMessage(this.channelId, this.id));
+  }
+  /**
+   * Format emoji for reaction API: unicode string or "name:id" for custom.
+   * @param emoji - Unicode emoji (e.g. "👍") or custom { name, id } or "name:id" string
+   */
+  static formatEmoji(emoji) {
+    if (typeof emoji === "string") return emoji;
+    return `${emoji.name}:${emoji.id}`;
+  }
+  /** Add a reaction to this message (as the bot). */
+  async react(emoji) {
+    const emojiStr = _Message.formatEmoji(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. */
+  async removeReaction(emoji, userId) {
+    const emojiStr = _Message.formatEmoji(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. Requires moderator permissions. */
+  async removeReactionEmoji(emoji) {
+    const emojiStr = _Message.formatEmoji(emoji);
+    await this.client.rest.delete(Routes.channelMessageReaction(this.channelId, this.id, emojiStr));
+  }
+};
+
+export {
+  Message
+};