Decouple compiler

packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lilybird",
-  "version": "0.8.0",
+  "version": "0.9.0-beta.4",
   "description": "A bun-first discord api wrapper written in TS",
   "main": "./dist/index.js",
   "author": "DidaS",

packages/core/src/enums/interaction.ts

@@ -46,15 +46,23 @@ export const enum ComponentType {
     UserSelect,
     RoleSelect,
     MentionableSelect,
-    ChannelSelect
+    ChannelSelect,
+    Section,
+    TextDisplay,
+    Thumbnail,
+    MediaGallery,
+    File,
+    Separator,
+    Container = 17
 }
 
 export const enum ButtonStyle {
     Primary = 1,
     Secondary,
     Success,
     Danger,
-    Link
+    Link,
+    Premium
 }
 
 export const enum TextInputStyle {

packages/core/src/enums/message.ts

@@ -49,7 +49,9 @@ export const enum MessageFlags {
     LOADING = 128,
     FAILED_TO_MENTION_SOME_ROLES_IN_THREAD = 256,
     SUPPRESS_NOTIFICATIONS = 4096,
-    IS_VOICE_MESSAGE = 8192
+    IS_VOICE_MESSAGE = 8192,
+    HAS_SNAPSHOT = 16384,
+    IS_COMPONENTS_V2 = 32768
 }
 
 export const enum AttachmentFlags {

packages/core/src/http/rest.ts

@@ -48,15 +48,18 @@ export class RestError extends Error {
 
 // I ran out of ideas for naming this thing
 type ExtractedData = ({ data: { attachments: Array<unknown> | undefined } } | { attachments: Array<unknown> | undefined }) & { reason?: string };
+export type TokenType = "Bearer" | "Bot";
 
 export class REST {
     // eslint-disable-next-line @typescript-eslint/naming-convention
     public static readonly BaseURL = "https://discord.com/api/v10/";
 
     #token?: string | undefined;
+    #tokenType: TokenType;
 
-    public constructor(token?: string) {
+    public constructor(token?: string, tokenType: TokenType = "Bot") {
         this.#token = token;
+        this.#tokenType = tokenType;
     }
 
     public async makeAPIRequest<T>(method: "GET" | "POST" | "PATCH" | "DELETE" | "PUT", path: string, data: FormData, reason?: string): Promise<T>;
@@ -65,7 +68,7 @@ export class REST {
         const opts: RequestInit = {
             method,
             headers: {
-                Authorization: `Bot ${this.#token}`,
+                Authorization: `${this.#tokenType} ${this.#token}`,
                 // eslint-disable-next-line @typescript-eslint/naming-convention
                 "User-Agent": `DiscordBot/LilyBird/${(<{ version: string }>packageJson).version}`
             }
@@ -128,8 +131,9 @@ export class REST {
         return <T> await response.json();
     }
 
-    public setToken(token: string | undefined): void {
+    public setToken(token: string | undefined, tokenType: TokenType = "Bot"): void {
         this.#token = token;
+        this.#tokenType = tokenType;
     }
 
     //#region Gateway
@@ -517,10 +521,6 @@ export class REST {
 
     //#endregion Emoji
     //#region Guild
-    public async createGuild(body: Guild.Create.GuildJSONParams): Promise<Guild.Structure> {
-        return this.makeAPIRequest("POST", "guilds", body);
-    }
-
     public async getGuild(guildId: string, withCounts = false): Promise<Guild.Structure> {
         return this.makeAPIRequest("GET", `guilds/${guildId}?with_counts=${withCounts}`);
     }

packages/core/src/index.ts

@@ -4,5 +4,7 @@ export { REST } from "./http/rest.js";
 export * as CDN from "./http/cdn.js";
 
 export * from "./enums/index.js";
+export * from "./ws/manager.js";
+export * from "./compiler.js";
 export * from "./client.js";
 export * from "./utils.js";

packages/core/src/typings/client.ts

@@ -1,14 +1,14 @@
-import type { CachingManager } from "../cache/manager.js";
 import type { CacheManagerStructure } from "./cache-manager.js";
+import type { CachingManager } from "../cache/manager.js";
+import type { DispatchFunction } from "../ws/manager.js";
+import type { Application } from "./application.js";
 import type { Awaitable } from "./utils.js";
-import type { Client } from "../client.js";
 
 import type {
     CachingDelegationType,
     TransformerReturnType,
     CacheExecutionPolicy,
-    DebugIdentifier,
-    Intents
+    DebugIdentifier
 } from "#enums";
 
 import type {
@@ -29,7 +29,6 @@ import type {
     GuildIntegrationsUpdate,
     MessageReactionRemove,
     MessagePollVoteRemove,
-    ReceiveDispatchEvent,
     GuildStickersUpdate,
     StageInstanceCreate,
     StageInstanceUpdate,
@@ -77,7 +76,7 @@ import type {
     Ready
 } from "./gateway-events.js";
 
-export type ClientListeners<T extends Transformers> = {
+export type Listeners<C, T extends Transformers<C>> = {
     [K in keyof T]?: T[K] extends { handler: unknown }
         ? (T[K] & {})["handler"] extends ((...args: any) => infer R)
             ? R extends [unknown, ...Array<unknown>] ? ((...arg: R) => Awaitable<unknown>) : ((arg: R) => Awaitable<unknown>)
@@ -87,79 +86,79 @@ export type ClientListeners<T extends Transformers> = {
             : never
 };
 
-export type Transformer<T> = {
+export type Transformer<C, T> = {
     return: TransformerReturnType,
-    handler: (...args: [client: Client, payload: T]) => unknown
+    handler: (...args: [client: C, payload: T]) => unknown
 };
 
-export interface Transformers {
-    raw?: {
-        return: TransformerReturnType,
-        handler: (data: ReceiveDispatchEvent) => unknown
-    };
-    ready?: Transformer<Ready["d"]>;
-    resumed?: Transformer<undefined>;
-    applicationCommandPermissionsUpdate?: Transformer<ApplicationCommandPermissionsUpdate["d"]>;
-    autoModerationRuleCreate?: Transformer<AutoModerationRuleCreate["d"]>;
-    autoModerationRuleUpdate?: Transformer<AutoModerationRuleUpdate["d"]>;
-    autoModerationRuleDelete?: Transformer<AutoModerationRuleDelete["d"]>;
-    autoModerationActionExecution?: Transformer<AutoModerationActionExecution["d"]>;
-    channelCreate?: Transformer<ChannelCreate["d"]>;
-    channelUpdate?: Transformer<ChannelUpdate["d"]>;
-    channelDelete?: Transformer<ChannelDelete["d"]>;
-    channelPinsUpdate?: Transformer<ChannelPinsUpdate["d"]>;
-    threadCreate?: Transformer<ThreadCreate["d"]>;
-    threadUpdate?: Transformer<ThreadUpdate["d"]>;
-    threadDelete?: Transformer<ThreadDelete["d"]>;
-    threadListSync?: Transformer<ThreadListSync["d"]>;
-    threadMemberUpdate?: Transformer<ThreadMemberUpdate["d"]>;
-    threadMembersUpdate?: Transformer<ThreadMembersUpdate["d"]>;
-    guildCreate?: Transformer<GuildCreate["d"]>;
-    guildUpdate?: Transformer<GuildUpdate["d"]>;
-    guildDelete?: Transformer<GuildDelete["d"]>;
-    guildAuditLogEntryCreate?: Transformer<GuildAuditLogEntryCreate["d"]>;
-    guildBanAdd?: Transformer<GuildBanAdd["d"]>;
-    guildBanRemove?: Transformer<GuildBanRemove["d"]>;
-    guildEmojisUpdate?: Transformer<GuildEmojisUpdate["d"]>;
-    guildStickersUpdate?: Transformer<GuildStickersUpdate["d"]>;
-    guildIntegrationsUpdate?: Transformer<GuildIntegrationsUpdate["d"]>;
-    guildMemberAdd?: Transformer<GuildMemberAdd["d"]>;
-    guildMemberRemove?: Transformer<GuildMemberRemove["d"]>;
-    guildMemberUpdate?: Transformer<GuildMemberUpdate["d"]>;
-    guildMembersChunk?: Transformer<GuildMembersChunk["d"]>;
-    guildRoleCreate?: Transformer<GuildRoleCreate["d"]>;
-    guildRoleUpdate?: Transformer<GuildRoleUpdate["d"]>;
-    guildRoleDelete?: Transformer<GuildRoleDelete["d"]>;
-    guildScheduledEventCreate?: Transformer<GuildScheduledEventCreate["d"]>;
-    guildScheduledEventUpdate?: Transformer<GuildScheduledEventUpdate["d"]>;
-    guildScheduledEventDelete?: Transformer<GuildScheduledEventDelete["d"]>;
-    guildScheduledEventUserAdd?: Transformer<GuildScheduledEventUserAdd["d"]>;
-    guildScheduledEventUserRemove?: Transformer<GuildScheduledEventUserRemove["d"]>;
-    integrationCreate?: Transformer<IntegrationCreate["d"]>;
-    integrationUpdate?: Transformer<IntegrationUpdate["d"]>;
-    integrationDelete?: Transformer<IntegrationDelete["d"]>;
-    interactionCreate?: Transformer<InteractionCreate["d"]>;
-    inviteCreate?: Transformer<InviteCreate["d"]>;
-    inviteDelete?: Transformer<InviteDelete["d"]>;
-    messageCreate?: Transformer<MessageCreate["d"]>;
-    messageUpdate?: Transformer<MessageUpdate["d"]>;
-    messageDelete?: Transformer<MessageDelete["d"]>;
-    messageDeleteBulk?: Transformer<MessageDeleteBulk["d"]>;
-    messageReactionAdd?: Transformer<MessageReactionAdd["d"]>;
-    messageReactionRemove?: Transformer<MessageReactionRemove["d"]>;
-    messageReactionRemoveAll?: Transformer<MessageReactionRemoveAll["d"]>;
-    messageReactionRemoveEmoji?: Transformer<MessageReactionRemoveEmoji["d"]>;
-    presenceUpdate?: Transformer<PresenceUpdate["d"]>;
-    stageInstanceCreate?: Transformer<StageInstanceCreate["d"]>;
-    stageInstanceUpdate?: Transformer<StageInstanceUpdate["d"]>;
-    stageInstanceDelete?: Transformer<StageInstanceCreate["d"]>;
-    typingStart?: Transformer<TypingStart["d"]>;
-    userUpdate?: Transformer<UserUpdate["d"]>;
-    voiceStateUpdate?: Transformer<VoiceStateUpdate["d"]>;
-    voiceServerUpdate?: Transformer<VoiceServerUpdate["d"]>;
-    webhookUpdate?: Transformer<WebhookUpdate["d"]>;
-    messagePollVoteAdd?: Transformer<MessagePollVoteAdd["d"]>;
-    messagePollVoteRemove?: Transformer<MessagePollVoteRemove["d"]>;
+export interface Transformers<C> {
+    /**
+     * Special case, its a `ready` handler that only fires once
+     */
+    setup?: Transformer<C, Ready["d"]>;
+    ready?: Transformer<C, Ready["d"]>;
+    resumed?: Transformer<C, undefined>;
+    applicationCommandPermissionsUpdate?: Transformer<C, ApplicationCommandPermissionsUpdate["d"]>;
+    autoModerationRuleCreate?: Transformer<C, AutoModerationRuleCreate["d"]>;
+    autoModerationRuleUpdate?: Transformer<C, AutoModerationRuleUpdate["d"]>;
+    autoModerationRuleDelete?: Transformer<C, AutoModerationRuleDelete["d"]>;
+    autoModerationActionExecution?: Transformer<C, AutoModerationActionExecution["d"]>;
+    channelCreate?: Transformer<C, ChannelCreate["d"]>;
+    channelUpdate?: Transformer<C, ChannelUpdate["d"]>;
+    channelDelete?: Transformer<C, ChannelDelete["d"]>;
+    channelPinsUpdate?: Transformer<C, ChannelPinsUpdate["d"]>;
+    threadCreate?: Transformer<C, ThreadCreate["d"]>;
+    threadUpdate?: Transformer<C, ThreadUpdate["d"]>;
+    threadDelete?: Transformer<C, ThreadDelete["d"]>;
+    threadListSync?: Transformer<C, ThreadListSync["d"]>;
+    threadMemberUpdate?: Transformer<C, ThreadMemberUpdate["d"]>;
+    threadMembersUpdate?: Transformer<C, ThreadMembersUpdate["d"]>;
+    guildCreate?: Transformer<C, GuildCreate["d"]>;
+    guildUpdate?: Transformer<C, GuildUpdate["d"]>;
+    guildDelete?: Transformer<C, GuildDelete["d"]>;
+    guildAuditLogEntryCreate?: Transformer<C, GuildAuditLogEntryCreate["d"]>;
+    guildBanAdd?: Transformer<C, GuildBanAdd["d"]>;
+    guildBanRemove?: Transformer<C, GuildBanRemove["d"]>;
+    guildEmojisUpdate?: Transformer<C, GuildEmojisUpdate["d"]>;
+    guildStickersUpdate?: Transformer<C, GuildStickersUpdate["d"]>;
+    guildIntegrationsUpdate?: Transformer<C, GuildIntegrationsUpdate["d"]>;
+    guildMemberAdd?: Transformer<C, GuildMemberAdd["d"]>;
+    guildMemberRemove?: Transformer<C, GuildMemberRemove["d"]>;
+    guildMemberUpdate?: Transformer<C, GuildMemberUpdate["d"]>;
+    guildMembersChunk?: Transformer<C, GuildMembersChunk["d"]>;
+    guildRoleCreate?: Transformer<C, GuildRoleCreate["d"]>;
+    guildRoleUpdate?: Transformer<C, GuildRoleUpdate["d"]>;
+    guildRoleDelete?: Transformer<C, GuildRoleDelete["d"]>;
+    guildScheduledEventCreate?: Transformer<C, GuildScheduledEventCreate["d"]>;
+    guildScheduledEventUpdate?: Transformer<C, GuildScheduledEventUpdate["d"]>;
+    guildScheduledEventDelete?: Transformer<C, GuildScheduledEventDelete["d"]>;
+    guildScheduledEventUserAdd?: Transformer<C, GuildScheduledEventUserAdd["d"]>;
+    guildScheduledEventUserRemove?: Transformer<C, GuildScheduledEventUserRemove["d"]>;
+    integrationCreate?: Transformer<C, IntegrationCreate["d"]>;
+    integrationUpdate?: Transformer<C, IntegrationUpdate["d"]>;
+    integrationDelete?: Transformer<C, IntegrationDelete["d"]>;
+    interactionCreate?: Transformer<C, InteractionCreate["d"]>;
+    inviteCreate?: Transformer<C, InviteCreate["d"]>;
+    inviteDelete?: Transformer<C, InviteDelete["d"]>;
+    messageCreate?: Transformer<C, MessageCreate["d"]>;
+    messageUpdate?: Transformer<C, MessageUpdate["d"]>;
+    messageDelete?: Transformer<C, MessageDelete["d"]>;
+    messageDeleteBulk?: Transformer<C, MessageDeleteBulk["d"]>;
+    messageReactionAdd?: Transformer<C, MessageReactionAdd["d"]>;
+    messageReactionRemove?: Transformer<C, MessageReactionRemove["d"]>;
+    messageReactionRemoveAll?: Transformer<C, MessageReactionRemoveAll["d"]>;
+    messageReactionRemoveEmoji?: Transformer<C, MessageReactionRemoveEmoji["d"]>;
+    presenceUpdate?: Transformer<C, PresenceUpdate["d"]>;
+    stageInstanceCreate?: Transformer<C, StageInstanceCreate["d"]>;
+    stageInstanceUpdate?: Transformer<C, StageInstanceUpdate["d"]>;
+    stageInstanceDelete?: Transformer<C, StageInstanceCreate["d"]>;
+    typingStart?: Transformer<C, TypingStart["d"]>;
+    userUpdate?: Transformer<C, UserUpdate["d"]>;
+    voiceStateUpdate?: Transformer<C, VoiceStateUpdate["d"]>;
+    voiceServerUpdate?: Transformer<C, VoiceServerUpdate["d"]>;
+    webhookUpdate?: Transformer<C, WebhookUpdate["d"]>;
+    messagePollVoteAdd?: Transformer<C, MessagePollVoteAdd["d"]>;
+    messagePollVoteRemove?: Transformer<C, MessagePollVoteRemove["d"]>;
 }
 
 export interface SelectiveCache {
@@ -216,31 +215,31 @@ export interface DefaultCache extends BaseCachingStructure {
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-export type ParseCachingManager<T extends ClientOptions<Transformers>> = T["caching"] extends {}
-    ? T["caching"]["applyTransformers"] extends true
-        ? T["caching"] extends { transformerTypes: (infer U extends CacheWithTransformers["transformerTypes"]) }
+export type ParseCachingManager<T extends CachingOptions> = T extends {}
+    ? T["applyTransformers"] extends true
+        ? T extends { transformerTypes: (infer U extends CacheWithTransformers["transformerTypes"]) }
             ? CachingManager<U["guild"], U["channel"], U["voiceState"]> : never
-        : T["caching"]["delegate"] extends CachingDelegationType.EXTERNAL
-            ? T["caching"]["manager"] & {}
+        : T["delegate"] extends CachingDelegationType.EXTERNAL
+            ? T["manager"] & {}
             : CachingManager
     : never;
 
 export type DebugFunction = (identifier: DebugIdentifier, payload?: unknown) => any;
 
-export interface BaseClientOptions<T extends Transformers> {
+export interface ClientOptions {
     intents: number;
-    listeners: ClientListeners<T>;
-    transformers?: T;
+    dispatch?: DispatchFunction;
     presence?: UpdatePresenceStructure;
-    caching?: (DefaultCache | ExternalCache | TransformersCache) & ApplyTransformers;
     useDebugRest?: boolean;
-    setup?: (client: Client) => Awaitable<any>;
+    cachingManager?: CacheManagerStructure;
 }
 
-export interface ClientOptions<T extends Transformers> extends Omit<BaseClientOptions<T>, "intents"> {
-    intents: Array<Intents> | number;
-    token: string;
-    attachDebugListener?: boolean;
-    customCacheKeys?: BaseCachingStructure["customKeys"];
-    debugListener?: (identifier: DebugIdentifier, payload: unknown) => void;
+export type CachingOptions = (DefaultCache | ExternalCache | TransformersCache) & ApplyTransformers;
+
+export interface MockClient {
+    /** By default this is a UserStructure, but can change according to your transformers*/
+    readonly user: any;
+    readonly sessionId: string;
+    readonly application: Application.Structure;
+    readonly cache: CacheManagerStructure;
 }

packages/core/src/typings/guild.ts

@@ -366,26 +366,6 @@ export declare namespace Guild {
     }
 
     export namespace Create {
-        /**
-         * @see {@link https://discord.com/developers/docs/resources/guild#create-guild-json-params}
-         */
-        export interface GuildJSONParams {
-            name: string;
-            icon?: DiscordImageData;
-            verification_level?: VerificationLevel;
-            default_message_notifications?: DefaultMessageNotificationLevel;
-            explicit_content_filter?: ExplicitContentFilterLevel;
-            roles?: Array<Role.Structure>;
-            channels?: Partial<Channel.Structure>;
-            afk_channel_id?: string;
-            afk_timeout?: number;
-            system_channel_id?: string;
-            /**
-             * Bitfield of {@link SystemChannelFlags}
-             */
-            system_channel_flags?: number;
-        }
-
         /**
          * @see {@link https://discord.com/developers/docs/resources/guild#create-guild-channel-json-params}
          */