bakit 2.1.2 → 2.2.0

package/dist/cli.js

@@ -9,7 +9,7 @@ import { startServiceServer } from '@bakit/service';
 // package.json
 var package_default = {
   name: "bakit",
-  version: "2.1.2"};
+  version: "2.2.0"};
 
 // src/lib/cli/index.ts
 config();

package/dist/index.d.ts

@@ -1,4 +1,146 @@
-export { DEFAULT_GATEWAY_MANAGER_OPTIONS, DEFAULT_WORKER_PATH, GatewayManager, GatewayManagerEvents, GatewayManagerOptions, GatewayWorker, GatewayWorkerEvents, GatewayWorkerOptions, GatewayWorkerState, createGatewayManager, createWorker } from '@bakit/gateway';
+import { REST } from '@bakit/rest';
 export { REST, RESTEndpoint, RESTEvents, RESTMethod, RESTOptions, createREST } from '@bakit/rest';
+import { EventBus } from '@bakit/utils';
 export { Awaitable, Collection, EventBus, EventMap, FunctionLike, Promisify, PromisifyValue, Queue, QueueOptions, ReadonlyCollection, RejectFn, ResolveFn, attachEventBus, capitalize, createEventBus, createQueue, isPlainObject, isPromiseLike, promisify, sleep } from '@bakit/utils';
+import { APIUser, APIMessage, ChannelType, Snowflake, APIChannel, APIChannelBase, APIGuildTextChannel, APIDMChannel, APIPublicThreadChannel, APIPrivateThreadChannel, APITextBasedChannel, TextChannelType, APIGuildChannel, GuildTextChannelType, APIThreadChannel, MessageFlags, GatewayReceivePayload } from 'discord-api-types/v10';
+import * as discord_api_types_globals from 'discord-api-types/globals';
+export { DEFAULT_GATEWAY_MANAGER_OPTIONS, DEFAULT_WORKER_PATH, GatewayManager, GatewayManagerEvents, GatewayManagerOptions, GatewayWorker, GatewayWorkerEvents, GatewayWorkerOptions, GatewayWorkerState, createGatewayManager, createWorker } from '@bakit/gateway';
 export { RPCError, RPCErrorPayload, RPCHandler, RPCRequestMessage, RPCResponseMessage, Serializable, Service, ServiceFunction, ServiceOptions, TransportClient, TransportClientOptions, TransportDriver, TransportServer, TransportServerOptions, createIPCClient, createIPCServer, createService, createTransportClient, createTransportServer, deserializeRPCError, getIPCPath, serializeRPCError } from '@bakit/service';
+
+interface User {
+    readonly client: Client;
+    readonly id: string;
+    readonly username: string;
+    readonly discriminator: string;
+    readonly globalName?: string | null;
+    readonly avatar?: string | null;
+    readonly system?: boolean;
+    readonly mfaEnabled?: boolean;
+    readonly banner?: string | null;
+    readonly accentColor?: number;
+    readonly locale?: string;
+    readonly verified?: boolean;
+    readonly email?: string | null;
+    readonly flags?: number;
+    readonly premiumType?: number;
+    readonly publicFlags?: number;
+}
+declare function createUser(client: Client, data: APIUser): User;
+
+interface Message {
+    readonly client: Client;
+    readonly id: string;
+    readonly channelId: string;
+    readonly author: User;
+    readonly content: string;
+    readonly timestamp: string;
+    readonly editedTimestamp?: string;
+    readonly tts: boolean;
+    readonly mentionEveryone: boolean;
+    readonly mentions: readonly User[];
+    readonly mentionRoles: readonly string[];
+    readonly nonce?: string | number;
+    readonly pinned: boolean;
+    readonly webhookId?: string;
+    readonly type: number;
+    readonly applicationId?: string;
+    readonly flags?: number;
+    readonly referencedMessage?: Message;
+    readonly position?: number;
+}
+declare function createMessage(client: Client, data: APIMessage): Message;
+
+interface TextBasedChannelSingleton {
+    lastMessageId?: Snowflake;
+    send(content: string): Promise<Message>;
+    send(options: CreateMessageOptions): Promise<Message>;
+    send(options: CreateMessageOptions | string): Promise<Message>;
+}
+interface VoiceBasedChannelSingleton {
+    join(): Promise<void>;
+}
+interface GuildBasedChannelSingleton {
+    readonly name: string;
+    readonly guildId?: Snowflake;
+    readonly parentId?: Snowflake;
+}
+interface GuildTextBasedChannelSingleton extends GuildBasedChannelSingleton, TextBasedChannelSingleton {
+}
+interface ThreadBasedChannelSingleton extends GuildTextBasedChannelSingleton {
+    readonly messageCount?: number;
+    readonly memberCount?: number;
+    readonly ownerId?: Snowflake;
+    readonly totalMessageSent?: number;
+    readonly appliedTags?: Snowflake[];
+}
+interface BaseChannel {
+    readonly client: Client;
+    readonly id: string;
+    readonly type: ChannelType;
+    isTextBased(): this is GuildTextChannel | DMChannel | PublicThreadChannel | PrivateThreadChannel;
+    isVoiceBased(): this is VoiceChannel | StageChannel;
+    isGuildBased(): this is GuildTextChannel | VoiceChannel | StageChannel | PublicThreadChannel | PrivateThreadChannel;
+    isThreadBased(): this is PublicThreadChannel | PrivateThreadChannel;
+    isDm(): this is DMChannel;
+    isGuildText(): this is GuildTextChannel;
+    isVoice(): this is VoiceChannel;
+    isStage(): this is StageChannel;
+    isPublicThread(): this is PublicThreadChannel;
+    isPrivateThread(): this is PrivateThreadChannel;
+}
+interface DMChannel extends BaseChannel, TextBasedChannelSingleton {
+    readonly recipients?: User[];
+}
+interface GuildTextChannel extends BaseChannel, GuildTextBasedChannelSingleton {
+}
+interface VoiceChannel extends GuildTextChannel, VoiceBasedChannelSingleton {
+}
+interface StageChannel extends GuildTextChannel, VoiceBasedChannelSingleton {
+}
+interface PublicThreadChannel extends BaseChannel, ThreadBasedChannelSingleton {
+}
+interface PrivateThreadChannel extends BaseChannel, ThreadBasedChannelSingleton {
+}
+type Channel = GuildTextChannel | DMChannel | PublicThreadChannel | VoiceChannel | StageChannel | BaseChannel;
+declare function createChannel(client: Client, data: APIChannel): Channel;
+declare function createBaseChannel(client: Client, data: APIChannelBase<ChannelType>): BaseChannel;
+declare function createGuildTextChannel(client: Client, data: APIGuildTextChannel<ChannelType.GuildText>): GuildTextChannel;
+declare function createDMChannel(client: Client, data: APIDMChannel): DMChannel;
+declare function createPublicThreadChannel(client: Client, data: APIPublicThreadChannel): PublicThreadChannel;
+declare function createPrivateThreadChannel(client: Client, data: APIPrivateThreadChannel): PrivateThreadChannel;
+declare function createVoiceChannel(client: Client, data: APIGuildTextChannel<ChannelType.GuildVoice>): VoiceChannel;
+declare function createStageChannel(client: Client, data: APIGuildTextChannel<ChannelType.GuildStageVoice>): StageChannel;
+declare function createTextBasedChannelSingleton(client: Client, data: APITextBasedChannel<TextChannelType>): TextBasedChannelSingleton;
+declare function createVoiceBasedChannelSingleton(_client: Client, _data: APIChannelBase<ChannelType.GuildVoice> | APIChannelBase<ChannelType.GuildStageVoice>): VoiceBasedChannelSingleton;
+declare function createGuildBasedChannelSingleton(data: APIGuildChannel): GuildBasedChannelSingleton;
+declare function createGuildTextBasedChannelSingleton(client: Client, data: APIGuildTextChannel<GuildTextChannelType>): GuildTextBasedChannelSingleton;
+declare function createThreadBasedChannelSingleton(client: Client, data: APIThreadChannel): ThreadBasedChannelSingleton;
+
+interface CreateMessageOptions {
+    content?: string;
+    flags?: MessageFlags;
+}
+
+declare function createHelpers(client: Client): {
+    user: {
+        getById(id: discord_api_types_globals.Snowflake): Promise<User | undefined>;
+        getCurrent(): Promise<User>;
+    };
+    channel: {
+        getById(id: discord_api_types_globals.Snowflake): Promise<Channel | undefined>;
+        createMessage(channelId: discord_api_types_globals.Snowflake, options: CreateMessageOptions | string): Promise<Message>;
+        deleteMessage(channelId: discord_api_types_globals.Snowflake, messageId: discord_api_types_globals.Snowflake): Promise<void>;
+    };
+};
+
+interface Client extends EventBus<ClientEvents> {
+    rest: REST;
+    helpers: ReturnType<typeof createHelpers>;
+}
+interface ClientEvents {
+    raw: [payload: GatewayReceivePayload];
+    messageCreate: [message: Message];
+}
+declare function createClient(rest: REST): Client;
+
+export { type BaseChannel, type Channel, type Client, type ClientEvents, type DMChannel, type GuildBasedChannelSingleton, type GuildTextBasedChannelSingleton, type GuildTextChannel, type Message, type PrivateThreadChannel, type PublicThreadChannel, type StageChannel, type TextBasedChannelSingleton, type ThreadBasedChannelSingleton, type User, type VoiceBasedChannelSingleton, type VoiceChannel, createBaseChannel, createChannel, createClient, createDMChannel, createGuildBasedChannelSingleton, createGuildTextBasedChannelSingleton, createGuildTextChannel, createMessage, createPrivateThreadChannel, createPublicThreadChannel, createStageChannel, createTextBasedChannelSingleton, createThreadBasedChannelSingleton, createUser, createVoiceBasedChannelSingleton, createVoiceChannel };

package/dist/index.js

@@ -1,4 +1,360 @@
+import { attachEventBus } from '@bakit/utils';
+export { Collection, attachEventBus, capitalize, createEventBus, createQueue, isPlainObject, isPromiseLike, promisify, sleep } from '@bakit/utils';
+import { ChannelType, GatewayDispatchEvents } from 'discord-api-types/v10';
 export { DEFAULT_GATEWAY_MANAGER_OPTIONS, DEFAULT_WORKER_PATH, createGatewayManager, createWorker } from '@bakit/gateway';
 export { createREST } from '@bakit/rest';
-export { Collection, attachEventBus, capitalize, createEventBus, createQueue, isPlainObject, isPromiseLike, promisify, sleep } from '@bakit/utils';
 export { RPCError, createIPCClient, createIPCServer, createService, createTransportClient, createTransportServer, deserializeRPCError, getIPCPath, serializeRPCError } from '@bakit/service';
+
+// src/lib/client/index.ts
+
+// src/lib/structures/user.ts
+function createUser(client, data) {
+  return {
+    get client() {
+      return client;
+    },
+    get id() {
+      return data.id;
+    },
+    get username() {
+      return data.username;
+    },
+    get discriminator() {
+      return data.discriminator;
+    },
+    get globalName() {
+      return data.global_name;
+    },
+    get avatar() {
+      return data.avatar;
+    },
+    get system() {
+      return data.system;
+    },
+    get mfaEnabled() {
+      return data.mfa_enabled;
+    },
+    get banner() {
+      return data.banner;
+    },
+    get accentColor() {
+      return data.accent_color ?? void 0;
+    },
+    get locale() {
+      return data.locale;
+    },
+    get verified() {
+      return data.verified;
+    },
+    get email() {
+      return data.email;
+    },
+    get flags() {
+      return data.flags;
+    },
+    get premiumType() {
+      return data.premium_type;
+    },
+    get publicFlags() {
+      return data.public_flags;
+    }
+  };
+}
+
+// src/lib/structures/message.ts
+function createMessage(client, data) {
+  let author, mentions, referencedMessage;
+  return {
+    get client() {
+      return client;
+    },
+    get id() {
+      return data.id;
+    },
+    get channelId() {
+      return data.channel_id;
+    },
+    get author() {
+      return author || (author = createUser(client, data.author)), author;
+    },
+    get content() {
+      return data.content;
+    },
+    get timestamp() {
+      return data.timestamp;
+    },
+    get editedTimestamp() {
+      return data.edited_timestamp ?? void 0;
+    },
+    get tts() {
+      return data.tts;
+    },
+    get mentionEveryone() {
+      return data.mention_everyone;
+    },
+    get mentions() {
+      return mentions || (mentions = data.mentions.map((x) => createUser(client, x))), mentions;
+    },
+    get mentionRoles() {
+      return data.mention_roles;
+    },
+    get nonce() {
+      return data.nonce;
+    },
+    get pinned() {
+      return data.pinned;
+    },
+    get webhookId() {
+      return data.webhook_id;
+    },
+    get type() {
+      return data.type;
+    },
+    get applicationId() {
+      return data.application_id;
+    },
+    get flags() {
+      return data.flags;
+    },
+    get referencedMessage() {
+      if (data.referenced_message)
+        return referencedMessage || (referencedMessage = createMessage(client, data.referenced_message)), referencedMessage;
+    },
+    get position() {
+      return data.position;
+    }
+  };
+}
+function createChannel(client, data) {
+  switch (data.type) {
+    case ChannelType.GuildText:
+      return createGuildTextChannel(client, data);
+    case ChannelType.DM:
+      return createDMChannel(client, data);
+    case ChannelType.PublicThread:
+      return createPublicThreadChannel(client, data);
+    case ChannelType.PrivateThread:
+      return createPrivateThreadChannel(client, data);
+    case ChannelType.GuildVoice:
+      return createVoiceChannel(client, data);
+    case ChannelType.GuildStageVoice:
+      return createStageChannel(client, data);
+    default:
+      return createBaseChannel(client, data);
+  }
+}
+function createBaseChannel(client, data) {
+  return {
+    get client() {
+      return client;
+    },
+    get id() {
+      return data.id;
+    },
+    get type() {
+      return data.type;
+    },
+    isTextBased() {
+      return data.type === ChannelType.GuildText || data.type === ChannelType.DM || data.type === ChannelType.PublicThread || data.type === ChannelType.PrivateThread;
+    },
+    isVoiceBased() {
+      return data.type === ChannelType.GuildVoice || data.type === ChannelType.GuildStageVoice;
+    },
+    isGuildBased() {
+      return data.type === ChannelType.GuildText || data.type === ChannelType.GuildVoice || data.type === ChannelType.GuildStageVoice || data.type === ChannelType.PublicThread || data.type === ChannelType.PrivateThread;
+    },
+    isThreadBased() {
+      return data.type === ChannelType.PublicThread || data.type === ChannelType.PrivateThread;
+    },
+    isDm() {
+      return data.type === ChannelType.DM;
+    },
+    isGuildText() {
+      return data.type === ChannelType.GuildText;
+    },
+    isVoice() {
+      return data.type === ChannelType.GuildVoice;
+    },
+    isStage() {
+      return data.type === ChannelType.GuildStageVoice;
+    },
+    isPublicThread() {
+      return data.type === ChannelType.PublicThread;
+    },
+    isPrivateThread() {
+      return data.type === ChannelType.PrivateThread;
+    }
+  };
+}
+function createGuildTextChannel(client, data) {
+  return {
+    ...createBaseChannel(client, data),
+    ...createGuildBasedChannelSingleton(data),
+    ...createTextBasedChannelSingleton(client, data)
+  };
+}
+function createDMChannel(client, data) {
+  let recipients;
+  return {
+    ...createBaseChannel(client, data),
+    ...createTextBasedChannelSingleton(client, data),
+    get recipients() {
+      if (data.recipients)
+        return recipients || (recipients = data.recipients.map((x) => createUser(client, x))), recipients;
+    }
+  };
+}
+function createPublicThreadChannel(client, data) {
+  return {
+    ...createBaseChannel(client, data),
+    ...createThreadBasedChannelSingleton(client, data)
+  };
+}
+function createPrivateThreadChannel(client, data) {
+  return {
+    ...createBaseChannel(client, data),
+    ...createThreadBasedChannelSingleton(client, data)
+  };
+}
+function createVoiceChannel(client, data) {
+  return {
+    ...createBaseChannel(client, data),
+    ...createVoiceBasedChannelSingleton(),
+    ...createGuildBasedChannelSingleton(data),
+    ...createTextBasedChannelSingleton(client, data)
+  };
+}
+function createStageChannel(client, data) {
+  return {
+    ...createBaseChannel(client, data),
+    ...createVoiceBasedChannelSingleton(),
+    ...createGuildBasedChannelSingleton(data),
+    ...createTextBasedChannelSingleton(client, data)
+  };
+}
+function createTextBasedChannelSingleton(client, data) {
+  return {
+    get lastMessageId() {
+      return data.last_message_id ?? void 0;
+    },
+    async send(options) {
+      return client.helpers.channel.createMessage(data.id, options);
+    }
+  };
+}
+function createVoiceBasedChannelSingleton(_client, _data) {
+  return {
+    async join() {
+    }
+  };
+}
+function createGuildBasedChannelSingleton(data) {
+  return {
+    get name() {
+      return data.name;
+    },
+    get guildId() {
+      return data.guild_id;
+    },
+    get parentId() {
+      return data.parent_id ?? void 0;
+    }
+  };
+}
+function createGuildTextBasedChannelSingleton(client, data) {
+  return {
+    ...createGuildBasedChannelSingleton(data),
+    ...createTextBasedChannelSingleton(client, data)
+  };
+}
+function createThreadBasedChannelSingleton(client, data) {
+  return {
+    ...createGuildTextBasedChannelSingleton(client, data),
+    get messageCount() {
+      return data.message_count;
+    },
+    get memberCount() {
+      return data.member_count;
+    },
+    get ownerId() {
+      return data.owner_id;
+    },
+    get totalMessageSent() {
+      return data.total_message_sent;
+    },
+    get appliedTags() {
+      return data.applied_tags;
+    }
+  };
+}
+
+// src/lib/client/helpers/channel.ts
+function createChannelHelpers(client) {
+  return {
+    async getById(id) {
+      try {
+        let data = await client.rest.get(`/channels/${id}`);
+        return createChannel(client, data);
+      } catch {
+        return;
+      }
+    },
+    async createMessage(channelId, options) {
+      typeof options == "string" && (options = { content: options });
+      let message = await client.rest.post(
+        `/channels/${channelId}/messages`,
+        {
+          content: options.content,
+          flags: options.flags
+        }
+      );
+      return createMessage(client, message);
+    },
+    async deleteMessage(channelId, messageId) {
+      await client.rest.delete(`/channels/${channelId}/messages/${messageId}`);
+    }
+  };
+}
+
+// src/lib/client/helpers/user.ts
+function createUserHelpers(client) {
+  return {
+    async getById(id) {
+      try {
+        let data = await client.rest.get(`/users/${id}`);
+        return createUser(client, data);
+      } catch {
+        return;
+      }
+    },
+    async getCurrent() {
+      let data = await client.rest.get("/users/@me");
+      return createUser(client, data);
+    }
+  };
+}
+
+// src/lib/client/helpers/index.ts
+function createHelpers(client) {
+  return {
+    user: createUserHelpers(client),
+    channel: createChannelHelpers(client)
+  };
+}
+
+// src/lib/client/index.ts
+function createClient(rest) {
+  let self = attachEventBus({
+    rest,
+    helpers: void 0
+  });
+  return Object.assign(self, createHelpers(self)), self.on("raw", (payload) => {
+    switch (payload.t) {
+      case GatewayDispatchEvents.MessageCreate:
+        self.emit("messageCreate", createMessage(self, payload.d));
+        return;
+    }
+  }), self;
+}
+
+export { createBaseChannel, createChannel, createClient, createDMChannel, createGuildBasedChannelSingleton, createGuildTextBasedChannelSingleton, createGuildTextChannel, createMessage, createPrivateThreadChannel, createPublicThreadChannel, createStageChannel, createTextBasedChannelSingleton, createThreadBasedChannelSingleton, createUser, createVoiceBasedChannelSingleton, createVoiceChannel };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bakit",
-  "version": "2.1.2",
+  "version": "2.2.0",
   "description": "A framework for discordeno",
   "type": "module",
   "exports": {
@@ -36,12 +36,13 @@
   },
   "dependencies": {
     "commander": "^14.0.2",
+    "discord-api-types": "^0.38.37",
     "dotenv": "^17.2.3",
     "tiny-glob": "^0.2.9",
     "type-fest": "^4.41.0",
-    "@bakit/gateway": "^2.1.4",
-    "@bakit/service": "^3.2.1",
     "@bakit/rest": "^2.1.0",
+    "@bakit/gateway": "^2.1.5",
+    "@bakit/service": "^3.2.1",
     "@bakit/utils": "^2.0.0"
   },
   "scripts": {