events and stuff

handlers/Actions.ts

@@ -1,39 +1,64 @@
-import type { DiscordMessage, DiscordReady } from "../vendor/external.ts";
+import type {
+    DiscordGuildMemberAdd,
+    DiscordGuildMemberRemove,
+    DiscordGuildMemberUpdate,
+    DiscordMessage,
+    DiscordMessageDelete,
+    DiscordReady,
+} from "../vendor/external.ts";
 import type { Snowflake } from "../util/Snowflake.ts";
 import type { Session } from "../session/Session.ts";
+import Member from "../structures/Member.ts";
 import Message from "../structures/Message.ts";
+import User from "../structures/User.ts";
 
-export type RawHandler<T extends unknown[]> = (...args: [Session, number, ...T]) => void;
+export type RawHandler<T> = (...args: [Session, number, T]) => void;
 export type Handler<T extends unknown[]> = (...args: T) => unknown;
 
-export type Ready = [DiscordReady];
+export const READY: RawHandler<DiscordReady> = (session, shardId, payload) => {
-export const READY: RawHandler<Ready> = (session, shardId, payload) => {
+    session.emit("ready", { ...payload, user: new User(session, payload.user) }, shardId);
-    session.emit("ready", payload, shardId);
 };
 
-export type MessageCreate = [DiscordMessage];
+export const MESSAGE_CREATE: RawHandler<DiscordMessage> = (session, _shardId, message) => {
-export const MESSAGE_CREATE: RawHandler<MessageCreate> = (session, _shardId, message) => {
     session.emit("messageCreate", new Message(session, message));
 };
 
-export type MessageUpdate = [DiscordMessage];
+export const MESSAGE_UPDATE: RawHandler<DiscordMessage> = (session, _shardId, new_message) => {
-export const MESSAGE_UPDATE: RawHandler<MessageUpdate> = (session, _shardId, new_message) => {
     session.emit("messageUpdate", new Message(session, new_message));
 };
 
-export type MessageDelete = [Snowflake];
+export const MESSAGE_DELETE: RawHandler<DiscordMessageDelete> = (session, _shardId, { id, channel_id, guild_id }) => {
-export const MESSAGE_DELETE: RawHandler<MessageDelete> = (session, _shardId, deleted_message_id) => {
+    session.emit("messageDelete", { id, channelId: channel_id, guildId: guild_id });
-    session.emit("messageDelete", deleted_message_id);
 };
 
-export const raw: RawHandler<[unknown]> = (session, shardId, data) => {
+export const GUILD_MEMBER_ADD: RawHandler<DiscordGuildMemberAdd> = (session, _shardId, member) => {
+    session.emit("guildMemberAdd", new Member(session, member, member.guild_id));
+};
+
+export const GUILD_MEMBER_UPDATE: RawHandler<DiscordGuildMemberUpdate> = (session, _shardId, member) => {
+    session.emit("guildMemberUpdate", new Member(session, member, member.guild_id));
+};
+
+export const GUILD_MEMBER_REMOVE: RawHandler<DiscordGuildMemberRemove> = (session, _shardId, member) => {
+    session.emit("guildMemberRemove", new User(session, member.user), member.guild_id);
+};
+
+export const raw: RawHandler<unknown> = (session, shardId, data) => {
     session.emit("raw", data, shardId);
 };
 
-export interface Events {
+export interface Ready extends Omit<DiscordReady, "user"> {
-    "ready": Handler<[DiscordReady, number]>;
+    user: User;
-    "messageCreate": Handler<[Message]>;
+}
-    "messageUpdate": Handler<[Message]>;
+
-    "messageDelete": Handler<[Snowflake]>;
+// deno-fmt-ignore-file
-    "raw": Handler<[unknown]>;
+export interface Events {
+    "ready":             Handler<[Ready, number]>;
+    "messageCreate":     Handler<[Message]>;
+    "messageUpdate":     Handler<[Message]>;
+    "messageDelete":     Handler<[{ id: Snowflake, channelId: Snowflake, guildId?: Snowflake }]>;
+    "guildMemberAdd":    Handler<[Member]>;
+    "guildMemberUpdate": Handler<[Member]>;
+    "guildMemberRemove": Handler<[User, Snowflake]>;
+    "raw":               Handler<[unknown, number]>;
 }

session/Session.ts

@@ -89,6 +89,11 @@ export class Session extends EventEmitter {
         return super.once(event, func);
     }
 
+    override emit<K extends keyof Events>(event: K, ...params: Parameters<Events[K]>): boolean;
+    override emit<K extends string>(event: K, ...params: unknown[]): boolean {
+        return super.emit(event, ...params);
+    }
+
     async start() {
         const getGatewayBot = () => this.rest.runMethod<DiscordGetGatewayBot>(this.rest, "GET", Routes.GATEWAY_BOT());
 

structures/Member.ts

@@ -1,7 +1,7 @@
 import type { Model } from "./Base.ts";
 import type { Snowflake } from "../util/Snowflake.ts";
 import type { Session } from "../session/Session.ts";
-import type { DiscordMember, MakeRequired } from "../vendor/external.ts";
+import type { DiscordMemberWithUser } from "../vendor/external.ts";
 import type { ImageFormat, ImageSize } from "../util/shared/images.ts";
 import { iconBigintToHash, iconHashToBigInt } from "../util/hash.ts";
 import User from "./User.ts";
@@ -23,9 +23,10 @@ export interface CreateGuildBan {
  * @link https://discord.com/developers/docs/resources/guild#guild-member-object
  */
 export class Member implements Model {
-    constructor(session: Session, data: MakeRequired<DiscordMember, "user">) {
+    constructor(session: Session, data: DiscordMemberWithUser, guildId: Snowflake) {
         this.session = session;
         this.user = new User(session, data.user);
+        this.guildId = guildId;
         this.avatarHash = data.avatar ? iconHashToBigInt(data.avatar) : undefined;
         this.nickname = data.nick ? data.nick : undefined;
         this.joinedTimestamp = Number.parseInt(data.joined_at);
@@ -39,8 +40,8 @@ export class Member implements Model {
     }
 
     readonly session: Session;
-
     user: User;
+    guildId: Snowflake;
     avatarHash?: bigint;
     nickname?: string;
     joinedTimestamp: number;
@@ -66,11 +67,11 @@ export class Member implements Model {
     /**
      * Bans the member
      */
-    async ban(guildId: Snowflake, options: CreateGuildBan): Promise<Member> {
+    async ban(options: CreateGuildBan): Promise<Member> {
         await this.session.rest.runMethod<undefined>(
             this.session.rest,
             "PUT",
-            Routes.GUILD_BAN(guildId, this.id),
+            Routes.GUILD_BAN(this.guildId, this.id),
             options
                 ? {
                     delete_message_days: options.deleteMessageDays,
@@ -85,11 +86,11 @@ export class Member implements Model {
     /**
      * Kicks the member
      */
-    async kick(guildId: Snowflake, { reason }: { reason?: string }): Promise<Member> {
+    async kick({ reason }: { reason?: string }): Promise<Member> {
         await this.session.rest.runMethod<undefined>(
             this.session.rest,
             "DELETE",
-            Routes.GUILD_MEMBER(guildId, this.id),
+            Routes.GUILD_MEMBER(this.guildId, this.id),
             { reason },
         );