@fluxerjs/core 1.0.2

package/dist/index.js

@@ -0,0 +1,665 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/structures/Base.ts
+var Base;
+var init_Base = __esm({
+  "src/structures/Base.ts"() {
+    "use strict";
+    Base = class {
+    };
+  }
+});
+
+// src/util/Constants.ts
+var CDN_URL;
+var init_Constants = __esm({
+  "src/util/Constants.ts"() {
+    "use strict";
+    CDN_URL = "https://fluxerusercontent.com";
+  }
+});
+
+// src/structures/User.ts
+var User;
+var init_User = __esm({
+  "src/structures/User.ts"() {
+    "use strict";
+    init_Base();
+    init_Constants();
+    User = class extends Base {
+      client;
+      id;
+      username;
+      discriminator;
+      globalName;
+      avatar;
+      bot;
+      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;
+      }
+      avatarURL(options) {
+        if (!this.avatar) return null;
+        const ext = options?.extension ?? "png";
+        const size = options?.size ? `?size=${options.size}` : "";
+        return `${CDN_URL}/avatars/${this.id}/${this.avatar}.${ext}${size}`;
+      }
+      displayAvatarURL(options) {
+        return this.avatarURL(options) ?? `${CDN_URL}/avatars/0/0.png`;
+      }
+      toString() {
+        return `<@${this.id}>`;
+      }
+    };
+  }
+});
+
+// src/structures/Message.ts
+var Message_exports = {};
+__export(Message_exports, {
+  Message: () => Message
+});
+var import_collection, import_types, Message;
+var init_Message = __esm({
+  "src/structures/Message.ts"() {
+    "use strict";
+    init_Base();
+    import_collection = require("@fluxerjs/collection");
+    import_types = require("@fluxerjs/types");
+    init_User();
+    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 import_collection.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(import_types.Routes.channelMessages(this.channelId), { body });
+        return new _Message(this.client, data);
+      }
+      async edit(options) {
+        const data = await this.client.rest.patch(import_types.Routes.channelMessage(this.channelId, this.id), { body: options });
+        return new _Message(this.client, data);
+      }
+      async delete() {
+        await this.client.rest.delete(import_types.Routes.channelMessage(this.channelId, this.id));
+      }
+    };
+  }
+});
+
+// src/structures/Guild.ts
+var Guild_exports = {};
+__export(Guild_exports, {
+  Guild: () => Guild
+});
+var import_collection2, Guild;
+var init_Guild = __esm({
+  "src/structures/Guild.ts"() {
+    "use strict";
+    init_Base();
+    import_collection2 = require("@fluxerjs/collection");
+    init_Constants();
+    Guild = class extends Base {
+      client;
+      id;
+      name;
+      icon;
+      banner;
+      ownerId;
+      members = new import_collection2.Collection();
+      channels = new import_collection2.Collection();
+      constructor(client, data) {
+        super();
+        this.client = client;
+        this.id = data.id;
+        this.name = data.name;
+        this.icon = data.icon ?? null;
+        this.banner = data.banner ?? null;
+        this.ownerId = data.owner_id;
+      }
+      iconURL(options) {
+        if (!this.icon) return null;
+        const size = options?.size ? `?size=${options.size}` : "";
+        return `${CDN_URL}/icons/${this.id}/${this.icon}.png${size}`;
+      }
+      bannerURL(options) {
+        if (!this.banner) return null;
+        const size = options?.size ? `?size=${options.size}` : "";
+        return `${CDN_URL}/banners/${this.id}/${this.banner}.png${size}`;
+      }
+    };
+  }
+});
+
+// src/structures/Channel.ts
+var Channel_exports = {};
+__export(Channel_exports, {
+  CategoryChannel: () => CategoryChannel,
+  Channel: () => Channel,
+  GuildChannel: () => GuildChannel,
+  LinkChannel: () => LinkChannel,
+  TextChannel: () => TextChannel,
+  VoiceChannel: () => VoiceChannel
+});
+var import_types2, Channel, GuildChannel, TextChannel, CategoryChannel, VoiceChannel, LinkChannel;
+var init_Channel = __esm({
+  "src/structures/Channel.ts"() {
+    "use strict";
+    init_Base();
+    import_types2 = require("@fluxerjs/types");
+    Channel = class extends Base {
+      client;
+      id;
+      type;
+      constructor(client, data) {
+        super();
+        this.client = client;
+        this.id = data.id;
+        this.type = data.type;
+      }
+      static from(client, data) {
+        const type = data.type ?? 0;
+        if (type === import_types2.ChannelType.GuildText) return new TextChannel(client, data);
+        if (type === import_types2.ChannelType.GuildCategory) return new CategoryChannel(client, data);
+        if (type === import_types2.ChannelType.GuildVoice) return new VoiceChannel(client, data);
+        if (type === import_types2.ChannelType.GuildLink) return new LinkChannel(client, data);
+        return new GuildChannel(client, data);
+      }
+    };
+    GuildChannel = class extends Channel {
+      guildId;
+      name;
+      position;
+      parentId;
+      constructor(client, data) {
+        super(client, data);
+        this.guildId = data.guild_id ?? "";
+        this.name = data.name ?? null;
+        this.position = data.position;
+        this.parentId = data.parent_id ?? null;
+      }
+    };
+    TextChannel = class extends GuildChannel {
+      topic;
+      nsfw;
+      rateLimitPerUser;
+      lastMessageId;
+      constructor(client, data) {
+        super(client, data);
+        this.topic = data.topic ?? null;
+        this.nsfw = data.nsfw ?? false;
+        this.rateLimitPerUser = data.rate_limit_per_user ?? 0;
+        this.lastMessageId = data.last_message_id ?? null;
+      }
+      async send(options) {
+        const body = typeof options === "string" ? { content: options } : options;
+        const { Message: Message2 } = await Promise.resolve().then(() => (init_Message(), Message_exports));
+        const data = await this.client.rest.post(import_types2.Routes.channelMessages(this.id), { body });
+        return new Message2(this.client, data);
+      }
+    };
+    CategoryChannel = class extends GuildChannel {
+    };
+    VoiceChannel = class extends GuildChannel {
+      bitrate;
+      userLimit;
+      rtcRegion;
+      constructor(client, data) {
+        super(client, data);
+        this.bitrate = data.bitrate ?? null;
+        this.userLimit = data.user_limit ?? null;
+        this.rtcRegion = data.rtc_region ?? null;
+      }
+    };
+    LinkChannel = class extends GuildChannel {
+      url;
+      constructor(client, data) {
+        super(client, data);
+        this.url = data.url ?? null;
+      }
+    };
+  }
+});
+
+// src/structures/GuildMember.ts
+var GuildMember_exports = {};
+__export(GuildMember_exports, {
+  GuildMember: () => GuildMember
+});
+var GuildMember;
+var init_GuildMember = __esm({
+  "src/structures/GuildMember.ts"() {
+    "use strict";
+    init_Base();
+    init_User();
+    GuildMember = class extends Base {
+      client;
+      id;
+      user;
+      guild;
+      nick;
+      roles;
+      joinedAt;
+      communicationDisabledUntil;
+      constructor(client, data, guild) {
+        super();
+        this.client = client;
+        this.user = new User(client, 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;
+      }
+      get displayName() {
+        return this.nick ?? this.user.globalName ?? this.user.username;
+      }
+    };
+  }
+});
+
+// src/client/ClientUser.ts
+var ClientUser_exports = {};
+__export(ClientUser_exports, {
+  ClientUser: () => ClientUser
+});
+var ClientUser;
+var init_ClientUser = __esm({
+  "src/client/ClientUser.ts"() {
+    "use strict";
+    init_User();
+    ClientUser = class extends User {
+      constructor(client, data) {
+        super(client, { ...data });
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AttachmentBuilder: () => import_builders.AttachmentBuilder,
+  Base: () => Base,
+  CategoryChannel: () => CategoryChannel,
+  Channel: () => Channel,
+  Client: () => Client,
+  ClientUser: () => ClientUser,
+  EmbedBuilder: () => import_builders.EmbedBuilder,
+  ErrorCodes: () => ErrorCodes,
+  Events: () => Events,
+  FluxerError: () => FluxerError,
+  GatewayOpcodes: () => import_types4.GatewayOpcodes,
+  Guild: () => Guild,
+  GuildChannel: () => GuildChannel,
+  GuildMember: () => GuildMember,
+  LinkChannel: () => LinkChannel,
+  Message: () => Message,
+  MessagePayload: () => import_builders.MessagePayload,
+  Routes: () => import_types4.Routes,
+  TextChannel: () => TextChannel,
+  User: () => User,
+  VoiceChannel: () => VoiceChannel
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client/Client.ts
+var import_events = require("events");
+var import_rest = require("@fluxerjs/rest");
+var import_ws = require("@fluxerjs/ws");
+var import_types3 = require("@fluxerjs/types");
+var import_collection3 = require("@fluxerjs/collection");
+
+// src/util/Events.ts
+var Events = {
+  Ready: "ready",
+  MessageCreate: "messageCreate",
+  MessageUpdate: "messageUpdate",
+  MessageDelete: "messageDelete",
+  InteractionCreate: "interactionCreate",
+  GuildCreate: "guildCreate",
+  GuildUpdate: "guildUpdate",
+  GuildDelete: "guildDelete",
+  ChannelCreate: "channelCreate",
+  ChannelUpdate: "channelUpdate",
+  ChannelDelete: "channelDelete",
+  GuildMemberAdd: "guildMemberAdd",
+  GuildMemberUpdate: "guildMemberUpdate",
+  GuildMemberRemove: "guildMemberRemove",
+  VoiceStateUpdate: "voiceStateUpdate",
+  VoiceServerUpdate: "voiceServerUpdate",
+  VoiceStatesSync: "voiceStatesSync",
+  Error: "error",
+  Debug: "debug"
+};
+
+// src/client/Client.ts
+var Client = class extends import_events.EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.options = options;
+    this.rest = new import_rest.REST({
+      api: options.rest?.api ?? "https://api.fluxer.app",
+      version: options.rest?.version ?? "1",
+      ...options.rest
+    });
+  }
+  rest;
+  guilds = new import_collection3.Collection();
+  channels = new import_collection3.Collection();
+  users = new import_collection3.Collection();
+  user = null;
+  readyAt = null;
+  _ws = null;
+  get ws() {
+    if (!this._ws) throw new Error("Client is not logged in");
+    return this._ws;
+  }
+  /** Send a payload to the gateway (e.g. Voice State Update). Uses shard 0 when single-shard. */
+  sendToGateway(shardId, payload) {
+    this.ws.send(shardId, payload);
+  }
+  async handleDispatch(payload) {
+    if (payload.op !== 0 || !payload.t) return;
+    const { t: event, d } = payload;
+    try {
+      switch (event) {
+        case "MESSAGE_CREATE": {
+          const { Message: Message2 } = await Promise.resolve().then(() => (init_Message(), Message_exports));
+          this.emit(Events.MessageCreate, new Message2(this, d));
+          break;
+        }
+        case "MESSAGE_UPDATE": {
+          const { Message: Message2 } = await Promise.resolve().then(() => (init_Message(), Message_exports));
+          this.emit(Events.MessageUpdate, null, new Message2(this, d));
+          break;
+        }
+        case "MESSAGE_DELETE":
+          this.emit(Events.MessageDelete, { id: d.id, channelId: d.channel_id });
+          break;
+        case "GUILD_CREATE": {
+          const { Guild: Guild2 } = await Promise.resolve().then(() => (init_Guild(), Guild_exports));
+          const { Channel: Channel2 } = await Promise.resolve().then(() => (init_Channel(), Channel_exports));
+          const guild = new Guild2(this, d);
+          this.guilds.set(guild.id, guild);
+          const g = d;
+          for (const ch of g.channels ?? []) {
+            const channel = Channel2.from(this, ch);
+            if (channel) this.channels.set(channel.id, channel);
+          }
+          this.emit(Events.GuildCreate, guild);
+          if (g.voice_states?.length) {
+            this.emit(Events.VoiceStatesSync, { guildId: guild.id, voiceStates: g.voice_states });
+          }
+          break;
+        }
+        case "GUILD_UPDATE": {
+          const { Guild: Guild2 } = await Promise.resolve().then(() => (init_Guild(), Guild_exports));
+          const g = d;
+          const old = this.guilds.get(g.id);
+          const updated = new Guild2(this, g);
+          this.guilds.set(updated.id, updated);
+          this.emit(Events.GuildUpdate, old ?? updated, updated);
+          break;
+        }
+        case "GUILD_DELETE": {
+          const g = d;
+          const guild = this.guilds.get(g.id);
+          if (guild) {
+            this.guilds.delete(g.id);
+            this.emit(Events.GuildDelete, guild);
+          }
+          break;
+        }
+        case "CHANNEL_CREATE": {
+          const { Channel: Channel2 } = await Promise.resolve().then(() => (init_Channel(), Channel_exports));
+          const ch = Channel2.from(this, d);
+          if (ch) {
+            this.channels.set(ch.id, ch);
+            this.emit(Events.ChannelCreate, ch);
+          }
+          break;
+        }
+        case "CHANNEL_UPDATE": {
+          const { Channel: Channel2 } = await Promise.resolve().then(() => (init_Channel(), Channel_exports));
+          const ch = d;
+          const oldCh = this.channels.get(ch.id);
+          const newCh = Channel2.from(this, ch);
+          if (newCh) {
+            this.channels.set(newCh.id, newCh);
+            this.emit(Events.ChannelUpdate, oldCh ?? newCh, newCh);
+          }
+          break;
+        }
+        case "CHANNEL_DELETE": {
+          const ch = d;
+          const channel = this.channels.get(ch.id);
+          if (channel) {
+            this.channels.delete(ch.id);
+            this.emit(Events.ChannelDelete, channel);
+          }
+          break;
+        }
+        case "GUILD_MEMBER_ADD": {
+          const { GuildMember: GuildMember2 } = await Promise.resolve().then(() => (init_GuildMember(), GuildMember_exports));
+          const data = d;
+          const guild = this.guilds.get(data.guild_id);
+          if (guild) {
+            const member = new GuildMember2(this, data, guild);
+            guild.members.set(member.id, member);
+            this.emit(Events.GuildMemberAdd, member);
+          }
+          break;
+        }
+        case "GUILD_MEMBER_UPDATE": {
+          const { GuildMember: GuildMember2 } = await Promise.resolve().then(() => (init_GuildMember(), GuildMember_exports));
+          const data = d;
+          const guild = this.guilds.get(data.guild_id);
+          if (guild) {
+            const oldM = guild.members.get(data.user.id);
+            const newM = new GuildMember2(this, data, guild);
+            guild.members.set(newM.id, newM);
+            this.emit(Events.GuildMemberUpdate, oldM ?? newM, newM);
+          }
+          break;
+        }
+        case "GUILD_MEMBER_REMOVE": {
+          const data = d;
+          const guild = this.guilds.get(data.guild_id);
+          if (guild) {
+            const member = guild.members.get(data.user.id);
+            if (member) {
+              guild.members.delete(data.user.id);
+              this.emit(Events.GuildMemberRemove, member);
+            }
+          }
+          break;
+        }
+        case "INTERACTION_CREATE": {
+          this.emit(Events.InteractionCreate, d);
+          break;
+        }
+        case "VOICE_STATE_UPDATE": {
+          this.emit(Events.VoiceStateUpdate, d);
+          break;
+        }
+        case "VOICE_SERVER_UPDATE": {
+          this.emit(Events.VoiceServerUpdate, d);
+          break;
+        }
+        default:
+          break;
+      }
+    } catch (err) {
+      this.emit(Events.Error, err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  async login(token) {
+    this.rest.setToken(token);
+    let intents = this.options.intents ?? 0;
+    if (intents !== 0) {
+      if (typeof process !== "undefined" && process.emitWarning) {
+        process.emitWarning(
+          "Fluxer does not support intents yet. Value has been set to 0.",
+          { type: "FluxerIntents" }
+        );
+      } else {
+        console.warn("Fluxer does not support intents yet. Value has been set to 0.");
+      }
+      intents = 0;
+    }
+    this._ws = new import_ws.WebSocketManager({
+      token,
+      intents,
+      rest: { get: (route) => this.rest.get(route) },
+      version: this.options.rest?.version ?? "1",
+      WebSocket: this.options.WebSocket
+    });
+    this._ws.on("dispatch", ({ payload }) => {
+      this.handleDispatch(payload);
+    });
+    this._ws.on("ready", async ({ data }) => {
+      const { ClientUser: ClientUser2 } = await Promise.resolve().then(() => (init_ClientUser(), ClientUser_exports));
+      const { Guild: Guild2 } = await Promise.resolve().then(() => (init_Guild(), Guild_exports));
+      const { Channel: Channel2 } = await Promise.resolve().then(() => (init_Channel(), Channel_exports));
+      this.user = new ClientUser2(this, data.user);
+      for (const g of data.guilds ?? []) {
+        const guild = new Guild2(this, g);
+        this.guilds.set(guild.id, guild);
+        const withCh = g;
+        for (const ch of withCh.channels ?? []) {
+          const channel = Channel2.from(this, ch);
+          if (channel) this.channels.set(channel.id, channel);
+        }
+        if (withCh.voice_states?.length) {
+          this.emit(Events.VoiceStatesSync, { guildId: guild.id, voiceStates: withCh.voice_states });
+        }
+      }
+      this.readyAt = /* @__PURE__ */ new Date();
+      this.emit(Events.Ready);
+    });
+    this._ws.on("error", ({ error }) => this.emit(Events.Error, error));
+    this._ws.on("debug", (msg) => this.emit(Events.Debug, msg));
+    await this._ws.connect();
+    return token;
+  }
+  async destroy() {
+    if (this._ws) {
+      this._ws.destroy();
+      this._ws = null;
+    }
+    this.rest.setToken(null);
+    this.user = null;
+    this.readyAt = null;
+    this.guilds.clear();
+    this.channels.clear();
+    this.users.clear();
+  }
+  isReady() {
+    return this.readyAt !== null && this.user !== null;
+  }
+  static get Routes() {
+    return import_types3.Routes;
+  }
+};
+
+// src/index.ts
+init_ClientUser();
+init_Base();
+init_User();
+init_Guild();
+init_Channel();
+init_Message();
+init_GuildMember();
+
+// src/errors/FluxerError.ts
+var FluxerError = class _FluxerError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FluxerError";
+    Object.setPrototypeOf(this, _FluxerError.prototype);
+  }
+};
+
+// src/errors/ErrorCodes.ts
+var ErrorCodes = {
+  ClientNotReady: "CLIENT_NOT_READY",
+  InvalidToken: "INVALID_TOKEN"
+};
+
+// src/index.ts
+var import_builders = require("@fluxerjs/builders");
+var import_types4 = require("@fluxerjs/types");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AttachmentBuilder,
+  Base,
+  CategoryChannel,
+  Channel,
+  Client,
+  ClientUser,
+  EmbedBuilder,
+  ErrorCodes,
+  Events,
+  FluxerError,
+  GatewayOpcodes,
+  Guild,
+  GuildChannel,
+  GuildMember,
+  LinkChannel,
+  Message,
+  MessagePayload,
+  Routes,
+  TextChannel,
+  User,
+  VoiceChannel
+});