@constatic/base 0.0.1-beta.1

package/README.md

@@ -0,0 +1,15 @@
+# template
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run ./src/index.ts
+```
+
+This project was created using `bun init` in bun v1.3.0. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/dist/app.d.ts

@@ -0,0 +1,41 @@
+import type { Client, CommandInteraction } from "discord.js";
+import { CommandManager } from "./creators/commands/manager.js";
+import type { EventPropData } from "./creators/events/event.js";
+import { EventManager } from "./creators/events/manager.js";
+import { ResponderManager, type GenericResponderInteraction } from "./creators/responders/manager.js";
+export interface BaseCommandsConfig {
+    guilds?: string[];
+    verbose?: boolean;
+    middleware?(interaction: CommandInteraction, block: () => void): Promise<void>;
+    onNotFound?(interaction: CommandInteraction): void;
+    onError?(error: unknown, interaction: CommandInteraction): void;
+}
+export interface BaseRespondersConfig {
+    middleware?(interaction: GenericResponderInteraction, block: () => void, params: object): Promise<void>;
+    onNotFound?(interaction: GenericResponderInteraction): void;
+    onError?(error: unknown, interaction: GenericResponderInteraction, params: object): void;
+}
+export interface BaseEventsConfig {
+    middleware?(event: EventPropData, block: (...tags: string[]) => void): Promise<void>;
+    onError?(error: unknown, event: EventPropData): void;
+}
+export type BaseErrorHandler = (error: Error | unknown, client: Client) => void;
+export interface BaseConfig {
+    commands: BaseCommandsConfig;
+    events: BaseEventsConfig;
+    responders: BaseRespondersConfig;
+    errorHandler: BaseErrorHandler;
+}
+export declare class ConstaticApp {
+    readonly commands: CommandManager;
+    readonly responders: ResponderManager;
+    readonly events: EventManager;
+    readonly config: BaseConfig;
+    private static "~instance";
+    static getInstance(): ConstaticApp;
+    private constructor();
+    static destroy(): void;
+    setErrorHandler(handler: BaseErrorHandler): void;
+    intro(): void;
+    printLogs(): void;
+}

package/dist/app.js

@@ -0,0 +1,51 @@
+// src/app.ts
+import { version } from "#package";
+import { version as djsVersion } from "discord.js";
+import { styleText } from "node:util";
+import { CommandManager } from "./creators/commands/manager.js";
+import { EventManager } from "./creators/events/manager.js";
+import { ResponderManager } from "./creators/responders/manager.js";
+import { baseErrorHandler } from "./error.js";
+var isBun = typeof Bun !== "undefined";
+
+class ConstaticApp {
+  commands = new CommandManager(this);
+  responders = new ResponderManager(this);
+  events = new EventManager(this);
+  config;
+  static "~instance" = null;
+  static getInstance() {
+    return this["~instance"] ??= new ConstaticApp;
+  }
+  constructor() {
+    this.config = {
+      commands: {},
+      responders: {},
+      events: {},
+      errorHandler: baseErrorHandler
+    };
+  }
+  static destroy() {
+    this["~instance"] = null;
+  }
+  setErrorHandler(handler) {
+    this.config.errorHandler = handler;
+  }
+  intro() {
+    console.log();
+    console.log("%s %s", styleText("blue", "★ Constatic Base"), styleText("dim", version));
+    console.log("%s %s | %s %s", styleText("blueBright", "◌ discord.js"), styleText("dim", djsVersion), isBun ? "◌ Bun" : styleText("green", "⬢ Node.js"), styleText("dim", isBun ? Bun.version : process.versions.node));
+    console.log();
+  }
+  printLogs() {
+    console.log([
+      ...this.commands.logs,
+      ...this.responders.logs,
+      ...this.events.logs
+    ].join(`
+`));
+  }
+}
+export {
+  ConstaticApp
+};

package/dist/bootstrap.d.ts

@@ -0,0 +1,18 @@
+import { type Client } from "discord.js";
+import { type BaseErrorHandler } from "./app.js";
+import { type CustomClientOptions } from "./client.js";
+export interface BootstrapOptions extends CustomClientOptions {
+    token?: string;
+    meta: ImportMeta;
+    errorHandler?: BaseErrorHandler;
+    beforeLoad?(client: Client<boolean>): Promise<void>;
+    modules?: string[];
+    loadLogs?: boolean;
+}
+export declare function bootstrap(options: BootstrapOptions): Promise<{
+    client: Client<boolean>;
+    imports: {
+        module: any;
+        filepath: string;
+    }[];
+}>;

package/dist/bootstrap.js

@@ -0,0 +1,35 @@
+// src/bootstrap.ts
+import { ConstaticApp } from "./app.js";
+import { createClient } from "./client.js";
+import { ConstaticError } from "./error.js";
+import { loadModules } from "./modules.js";
+async function bootstrap(options) {
+  const token = options.token ?? process.env.BOT_TOKEN;
+  if (!token)
+    throw new ConstaticError("The application token was not provided!");
+  const app = ConstaticApp.getInstance();
+  if (options.errorHandler) {
+    app.setErrorHandler(options.errorHandler);
+  }
+  const client = createClient(token, options);
+  process.on("uncaughtException", (error) => app.config.errorHandler(error, client));
+  process.on("unhandledRejection", (error) => app.config.errorHandler(error, client));
+  if (options.beforeLoad) {
+    await options.beforeLoad(client);
+  }
+  const imports = await loadModules(options.meta, [
+    "./discord/**/*.{js,ts,jsx,tsx}",
+    "!./discord/index.{js,ts,jsx,tsx}",
+    ...options.modules ?? []
+  ]);
+  if (options.loadLogs ?? true) {
+    app.printLogs();
+  }
+  app.intro();
+  app.events.register(client);
+  client.login();
+  return { client, imports };
+}
+export {
+  bootstrap
+};

package/dist/client.d.ts

@@ -0,0 +1,3 @@
+import { Client, type ClientOptions } from "discord.js";
+export type CustomClientOptions = Partial<ClientOptions>;
+export declare function createClient(token: string, options: CustomClientOptions): Client<boolean>;

package/dist/client.js

@@ -0,0 +1,34 @@
+// src/client.ts
+import { Client } from "discord.js";
+import { styleText } from "node:util";
+import { ConstaticApp } from "./app.js";
+function createClient(token, options) {
+  const app = ConstaticApp.getInstance();
+  const client = new Client({
+    ...options,
+    intents: options.intents ?? [],
+    partials: options.partials ?? [],
+    failIfNotExists: options.failIfNotExists ?? false
+  });
+  client.token = token;
+  client.once("clientReady", async (client2) => {
+    console.log("%s %s %s", styleText("green", "●"), styleText(["greenBright", "underline"], client2.user.username), styleText("green", "application is ready!"));
+    await app.commands.register(client2);
+    await app.events.runReady(client2);
+  });
+  client.on("interactionCreate", async (interaction) => {
+    if (interaction.isAutocomplete()) {
+      await app.commands.onAutocomplete(interaction);
+      return;
+    }
+    if (interaction.isCommand()) {
+      await app.commands.onCommand(interaction);
+      return;
+    }
+    await app.responders.onResponder(interaction);
+  });
+  return client;
+}
+export {
+  createClient
+};

package/dist/creators/commands/command.d.ts

@@ -0,0 +1,92 @@
+import { ApplicationCommandOptionType, ApplicationCommandType, AutocompleteInteraction, ChatInputCommandInteraction, MessageContextMenuCommandInteraction, UserContextMenuCommandInteraction, type ApplicationCommandOptionAllowedChannelTypes, type ApplicationCommandOptionChoiceData, type BaseApplicationCommandData, type CacheType, type LocalizationMap } from "discord.js";
+export type CommandType = Exclude<ApplicationCommandType, ApplicationCommandType.PrimaryEntryPoint>;
+type AutocompleData<Type> = Promise<readonly ApplicationCommandOptionChoiceData<Type extends (number | string) ? Type : (number | string)>[] | undefined | void>;
+export type AutocompleteRun<Type, Perm> = (this: void, interaction: AutocompleteInteraction<CacheMode<Perm>>) => AutocompleData<Type>;
+interface AutocompleteOptionData<Type, Perm> {
+    autocomplete?: true | AutocompleteRun<Type, Perm>;
+}
+interface BaseOptionData {
+    name: string;
+    nameLocalizations?: LocalizationMap;
+    description?: string;
+    descriptionLocalizations?: LocalizationMap;
+    required?: boolean;
+}
+interface StringOptionData<Perm> extends BaseOptionData, AutocompleteOptionData<string, Perm> {
+    type: ApplicationCommandOptionType.String;
+    choices?: readonly ApplicationCommandOptionChoiceData<string>[];
+    minLength?: number;
+    maxLength?: number;
+}
+interface NumberOptionData<P> extends BaseOptionData, AutocompleteOptionData<number, P> {
+    type: ApplicationCommandOptionType.Number | ApplicationCommandOptionType.Integer;
+    choices?: readonly ApplicationCommandOptionChoiceData<number>[];
+    minValue?: number;
+    maxValue?: number;
+}
+interface ChannelOptionData extends BaseOptionData {
+    type: ApplicationCommandOptionType.Channel;
+    channelTypes?: readonly ApplicationCommandOptionAllowedChannelTypes[];
+}
+interface CommonOptionData extends BaseOptionData {
+    type: ApplicationCommandOptionType.Attachment | ApplicationCommandOptionType.Boolean | ApplicationCommandOptionType.Mentionable | ApplicationCommandOptionType.Role | ApplicationCommandOptionType.User;
+}
+export type SlashCommandPrimitiveOptionData<Perm> = StringOptionData<Perm> | NumberOptionData<Perm> | CommonOptionData | ChannelOptionData;
+export interface SubCommandOptionData<Perm> extends Omit<BaseOptionData, "required"> {
+    type: ApplicationCommandOptionType.Subcommand;
+    options?: SlashCommandPrimitiveOptionData<Perm>[];
+}
+export interface GroupOptionData<Perm> extends Omit<BaseOptionData, "required"> {
+    type: ApplicationCommandOptionType.SubcommandGroup;
+    options: SubCommandOptionData<Perm>[];
+}
+type CacheMode<Perm> = Perm extends false ? "cached" : CacheType;
+interface CommandRunThis {
+    /**
+     * Blocks the flow of executions
+     */
+    block(): never;
+}
+type ResolveCommandModuleData<Return> = Return extends void ? undefined : Return;
+export type SubCommandModuleData<Perm, Return> = Omit<BaseOptionData, "required"> & {
+    group?: string;
+    run(this: CommandRunThis, interaction: ChatInputCommandInteraction<CacheMode<Perm>>, data: ResolveCommandModuleData<Return>): Promise<void>;
+    options?: SlashCommandPrimitiveOptionData<Perm>[];
+};
+export type SubCommandGroupModuleData<Perm, Return, T> = Omit<BaseOptionData, "required"> & {
+    options?: Omit<SubCommandOptionData<Perm>, "type">[];
+    run?(this: CommandRunThis, interaction: ChatInputCommandInteraction<CacheMode<Perm>>, data: ResolveCommandModuleData<Return>): Promise<T>;
+};
+type RunInteraction<T, P> = T extends ApplicationCommandType.Message ? MessageContextMenuCommandInteraction<CacheMode<P>> : T extends ApplicationCommandType.User ? UserContextMenuCommandInteraction<CacheMode<P>> : ChatInputCommandInteraction<CacheMode<P>>;
+type BaseAppCommandData = Omit<BaseApplicationCommandData, "dmPermission"> & Pick<BaseOptionData, "descriptionLocalizations">;
+export interface CommandData<T, P, R> extends BaseAppCommandData {
+    name: string;
+    description?: string;
+    dmPermission?: P;
+    type?: T;
+    global?: boolean;
+    run?(this: CommandRunThis, interaction: RunInteraction<T, P>): Promise<R>;
+    autocomplete?: AutocompleteRun<string | number, P>;
+    options?: SlashCommandPrimitiveOptionData<P>[] | (GroupOptionData<P> | SubCommandOptionData<P>)[];
+}
+export type SlashCommandOptionData<Perm> = SlashCommandPrimitiveOptionData<Perm> | GroupOptionData<Perm> | SubCommandOptionData<Perm>;
+export type CommandModule = (SubCommandGroupModuleData<unknown, unknown, unknown> & {
+    type: ApplicationCommandOptionType.SubcommandGroup;
+}) | (SubCommandModuleData<unknown, unknown> & {
+    type: ApplicationCommandOptionType.Subcommand;
+    group?: string;
+});
+declare class GroupCommandModule<Type, Perm, Return, ModuleReturn> {
+    readonly command: Command<Type, Perm, Return>;
+    readonly data: SubCommandGroupModuleData<Perm, Return, ModuleReturn>;
+    constructor(command: Command<Type, Perm, Return>, data: SubCommandGroupModuleData<Perm, Return, ModuleReturn>);
+    subcommand(data: SubCommandModuleData<Perm, ModuleReturn>): this;
+}
+export declare class Command<Type, Perm, Return> {
+    readonly data: CommandData<Type, Perm, Return>;
+    readonly modules: CommandModule[];
+    constructor(data: CommandData<Type, Perm, Return>);
+    group<ModuleReturn>(data: SubCommandGroupModuleData<Perm, Return, ModuleReturn>): GroupCommandModule<Type, Perm, Return, ModuleReturn>;
+    subcommand<Return>(data: SubCommandModuleData<Perm, Return>): this;
+}
+export {};

package/dist/creators/commands/command.js

@@ -0,0 +1,50 @@
+// src/creators/commands/command.ts
+import { ApplicationCommandOptionType, ApplicationCommandType } from "discord.js";
+
+class GroupCommandModule {
+  command;
+  data;
+  constructor(command, data) {
+    this.command = command;
+    this.data = data;
+  }
+  subcommand(data) {
+    data.group ??= this.data.name;
+    this.command.subcommand(data);
+    return this;
+  }
+}
+
+class Command {
+  data;
+  modules = [];
+  constructor(data) {
+    this.data = data;
+    this.data.type ??= ApplicationCommandType.ChatInput;
+    this.data.dmPermission ??= false;
+    if (this.data.type === ApplicationCommandType.ChatInput) {
+      this.data.description ??= this.data.name;
+      this.data.name = this.data.name.toLowerCase().replaceAll(" ", "");
+    }
+    if (this.data.name.length > 32) {
+      this.data.name = this.data.name.slice(0, 32);
+    }
+  }
+  group(data) {
+    this.modules.push({
+      ...data,
+      type: ApplicationCommandOptionType.SubcommandGroup
+    });
+    return new GroupCommandModule(this, data);
+  }
+  subcommand(data) {
+    this.modules.push({
+      ...data,
+      type: ApplicationCommandOptionType.Subcommand
+    });
+    return this;
+  }
+}
+export {
+  Command
+};

package/dist/creators/commands/manager.d.ts

@@ -0,0 +1,22 @@
+import { ApplicationCommandType, AutocompleteInteraction, Client, CommandInteraction, type ChatInputApplicationCommandData, type MessageApplicationCommandData, type UserApplicationCommandData } from "discord.js";
+import { BaseManager } from "../manager.js";
+import type { Command, CommandType } from "./command.js";
+type Runner = Function | null | undefined;
+type BuildedCommandData = (UserApplicationCommandData | MessageApplicationCommandData | ChatInputApplicationCommandData) & {
+    global?: boolean;
+};
+export declare class CommandManager extends BaseManager {
+    private get config();
+    private readonly collection;
+    readonly runners: Map<string, Runner[]>;
+    set<T, P, R>(command: Command<T, P, R>): void;
+    getTitle(type?: CommandType): string[];
+    build(): BuildedCommandData[];
+    private buildOptions;
+    private buildModules;
+    getHandler(type: ApplicationCommandType, ...path: (string | null)[]): Runner[] | undefined;
+    onAutocomplete(interaction: AutocompleteInteraction): Promise<void>;
+    onCommand(interaction: CommandInteraction): Promise<void>;
+    register(client: Client<true>): Promise<void>;
+}
+export {};

package/dist/creators/commands/manager.js

@@ -0,0 +1,221 @@
+// src/creators/commands/manager.ts
+import { ApplicationCommandOptionType, ApplicationCommandType } from "discord.js";
+import { format, styleText } from "node:util";
+import { RunBlockError } from "../../error.js";
+import { BaseManager } from "../manager.js";
+
+class CommandManager extends BaseManager {
+  get config() {
+    return this.app.config.commands;
+  }
+  collection = new Map;
+  runners = new Map;
+  set(command) {
+    this.collection.set(command.data.name, command);
+    const path = `/${command.data.type}/${command.data.name}`;
+    this.runners.set(path, [command.data.run]);
+    if (command.data.autocomplete) {
+      this.runners.set(`${path}/autocomplete`, [command.data.autocomplete]);
+    }
+    const [icon, label] = this.getTitle(command.data.type);
+    this.logs.push([
+      styleText("green", `${icon} ${label}`),
+      styleText("gray", `>`),
+      styleText(["blue", "underline"], command.data.name),
+      styleText("green", "✓")
+    ].join(" "));
+  }
+  getTitle(type) {
+    return {
+      [ApplicationCommandType.ChatInput]: ["{/}", "Slash command"],
+      [ApplicationCommandType.User]: ["{☰}", "User context menu"],
+      [ApplicationCommandType.Message]: ["{☰}", "Message context menu"]
+    }[type ?? ApplicationCommandType.ChatInput];
+  }
+  build() {
+    const commands = Array.from(this.collection.values());
+    return commands.map((command) => {
+      const {
+        options: rawOptions,
+        description,
+        descriptionLocalizations,
+        ...data
+      } = command.data;
+      const path = `/${data.type}/${data.name}`;
+      const modulesOptions = this.buildModules(command.modules, path, data.run);
+      const options = this.buildOptions([
+        ...rawOptions ?? [],
+        ...modulesOptions
+      ], path);
+      const slashData = data.type === ApplicationCommandType.ChatInput ? {
+        description,
+        descriptionLocalizations,
+        ...options.length >= 1 ? { options } : {}
+      } : {};
+      return { ...data, ...slashData };
+    });
+  }
+  buildOptions(options, path) {
+    const resolved = [];
+    for (const option of options) {
+      const description = option.description ?? option.name;
+      if ("autocomplete" in option && option.autocomplete && typeof option.autocomplete === "function") {
+        this.runners.set(`${path}/autocomplete/${option.name}`, [option.autocomplete]);
+      }
+      switch (option.type) {
+        case ApplicationCommandOptionType.SubcommandGroup: {
+          const { options: subcommands, ...data } = option;
+          resolved.push({
+            ...data,
+            description,
+            options: this.buildOptions(subcommands, `${path}/${data.name}`)
+          });
+          continue;
+        }
+        case ApplicationCommandOptionType.Subcommand: {
+          const { options: options2, ...data } = option;
+          resolved.push({
+            ...data,
+            description,
+            ...options2?.length ? {
+              options: this.buildOptions(options2, `${path}/${data.name}`)
+            } : {}
+          });
+          continue;
+        }
+        case ApplicationCommandOptionType.String:
+        case ApplicationCommandOptionType.Integer:
+        case ApplicationCommandOptionType.Number: {
+          const { choices, autocomplete, ...data } = option;
+          const validation = data.type === ApplicationCommandOptionType.String ? { minLength: data.minLength, maxLength: data.maxLength } : { minValue: data.minValue, maxValue: data.maxValue };
+          const extra = autocomplete ? { autocomplete: true, ...validation } : choices?.length ? { choices: choices.slice(0, 25) } : validation;
+          resolved.push(Object.assign({
+            ...data,
+            description,
+            ...extra
+          }));
+          continue;
+        }
+        default: {
+          resolved.push({ ...option, description });
+        }
+      }
+    }
+    return resolved;
+  }
+  buildModules(modules, path, run) {
+    const resolved = [];
+    if (!modules.length)
+      return resolved;
+    const groups = modules.filter((module) => module.type === ApplicationCommandOptionType.SubcommandGroup);
+    const subcommands = modules.filter((module) => module.type === ApplicationCommandOptionType.Subcommand);
+    if (groups.length >= 1) {
+      for (const group of groups) {
+        const data = [
+          ...(group.options ?? []).map((data2) => ({
+            ...data2,
+            type: ApplicationCommandOptionType.Subcommand
+          })),
+          ...subcommands.filter((sub) => sub.group === group.name)
+        ];
+        resolved.push({ ...group, options: data });
+        for (const subcommand of data) {
+          this.runners.set(`${path}/${group.name}/${subcommand.name}`, [run, group.run, subcommand.run]);
+        }
+      }
+    }
+    for (const subcommand of subcommands.filter((sub) => !sub.group)) {
+      this.runners.set(`${path}/${subcommand.name}`, [run, subcommand.run]);
+      resolved.push(subcommand);
+    }
+    return resolved;
+  }
+  getHandler(type, ...path) {
+    const commandName = path[0];
+    const resolved = `/${type}/${path.filter((p) => p !== null).join("/")}`;
+    return this.runners.get(resolved) ?? this.runners.get(`/${type}/${commandName}`);
+  }
+  async onAutocomplete(interaction) {
+    const options = interaction.options;
+    const handler = this.getHandler(interaction.commandType, interaction.commandName, "autocomplete", options.getSubcommandGroup(false), options.getSubcommand(false), options.getFocused(true).name);
+    if (!handler || !handler[0])
+      return;
+    const [run] = handler;
+    const choices = await run(interaction);
+    if (choices && Array.isArray(choices)) {
+      await interaction.respond(choices.slice(0, 25));
+    }
+  }
+  async onCommand(interaction) {
+    if (interaction.isPrimaryEntryPointCommand())
+      return;
+    const { middleware, onError, onNotFound } = this.config;
+    let isBlock = false;
+    const block = () => isBlock = true;
+    if (middleware)
+      await middleware(interaction, block);
+    if (isBlock)
+      return;
+    const path = [interaction.commandName];
+    if (interaction.isChatInputCommand()) {
+      path.push(interaction.options.getSubcommandGroup(false), interaction.options.getSubcommand(false));
+    }
+    const handler = this.getHandler(interaction.commandType, ...path);
+    if (!handler) {
+      onNotFound?.(interaction);
+      return;
+    }
+    try {
+      let result;
+      for (const run of handler.filter((h) => h !== null && h !== undefined)) {
+        result = await run.call({
+          block() {
+            throw new RunBlockError;
+          }
+        }, interaction, result);
+      }
+    } catch (err) {
+      if (err instanceof RunBlockError)
+        return;
+      if (onError) {
+        onError(err, interaction);
+        return;
+      }
+      throw err;
+    }
+  }
+  async register(client) {
+    const guildList = new Set(this.config.guilds);
+    const commands = this.build();
+    const promises = [];
+    const manager = client.application.commands;
+    const logs = [];
+    const setGlobal = (commands2) => {
+      promises.push(manager.set(commands2).then((data) => logs.push([
+        data.size,
+        `${client.user.username} application`
+      ])));
+    };
+    if (guildList.size >= 1) {
+      const guildCommands = commands.filter((c) => !c.global);
+      for (const id of guildList.values()) {
+        promises.push(manager.set(guildCommands, id).then((commands2) => logs.push([
+          commands2.size,
+          `${id} guild`
+        ])));
+      }
+      const globalCommands = commands.filter((c) => c.global);
+      if (globalCommands.length >= 1) {
+        setGlobal(globalCommands);
+      }
+    } else {
+      setGlobal(commands);
+    }
+    await Promise.all(promises);
+    console.log(logs.map(([size, location]) => format(styleText("green", "└ %s command%s registered in %s"), size, size === 1 ? "" : "s", styleText("greenBright", location))).join(`
+`));
+  }
+}
+export {
+  CommandManager
+};

package/dist/creators/events/event.d.ts

@@ -0,0 +1,21 @@
+import type { ClientEvents } from "discord.js";
+export type ClientEventKey = keyof ClientEvents;
+export type EventPropData = {
+    [Key in ClientEventKey]: {
+        name: Key;
+        args: ClientEvents[Key];
+    };
+}[ClientEventKey];
+export interface EventData<EventName extends ClientEventKey> {
+    name: string;
+    event: EventName;
+    once?: boolean;
+    tags?: string[];
+    run(this: void, ...args: ClientEvents[EventName]): Promise<void>;
+}
+export declare class Event<EventName extends ClientEventKey> {
+    readonly data: EventData<EventName>;
+    constructor(data: EventData<EventName>);
+}
+export type GenericEventArgs = ClientEvents[ClientEventKey];
+export type EventsCollection = Map<string, Event<ClientEventKey>>;

package/dist/creators/events/event.js

@@ -0,0 +1,10 @@
+// src/creators/events/event.ts
+class Event {
+  data;
+  constructor(data) {
+    this.data = data;
+  }
+}
+export {
+  Event
+};

package/dist/creators/events/manager.d.ts

@@ -0,0 +1,12 @@
+import { Client, Collection } from "discord.js";
+import { BaseManager } from "../manager.js";
+import type { ClientEventKey, Event, EventsCollection, GenericEventArgs } from "./event.js";
+export declare class EventManager extends BaseManager {
+    private get config();
+    readonly collection: Collection<keyof import("discord.js").ClientEvents, EventsCollection>;
+    getEvents(key: ClientEventKey): EventsCollection;
+    add(event: Event<ClientEventKey>): void;
+    onEvent(event: Event<ClientEventKey>, args: GenericEventArgs): Promise<void>;
+    register(client: Client): void;
+    runReady(client: Client<true>): Promise<void>;
+}

package/dist/creators/events/manager.js

@@ -0,0 +1,62 @@
+// src/creators/events/manager.ts
+import { Collection } from "discord.js";
+import { BaseManager } from "../manager.js";
+
+class EventManager extends BaseManager {
+  get config() {
+    return this.app.config.events;
+  }
+  collection = new Collection;
+  getEvents(key) {
+    if (!this.collection.has(key)) {
+      this.collection.set(key, new Map);
+    }
+    return this.collection.get(key);
+  }
+  add(event) {
+    const events = this.getEvents(event.data.event);
+    events.set(event.data.name, event);
+  }
+  async onEvent(event, args) {
+    const { middleware, onError } = this.config;
+    let isBlock = false;
+    const block = (...selected) => {
+      const tags = event.data.tags ?? [];
+      if (selected.length === 0) {
+        isBlock = tags.length === 0;
+        return;
+      }
+      isBlock = selected.some((tag) => tags.includes(tag));
+    };
+    const eventData = { name: event.data.name, args };
+    if (middleware)
+      await middleware(eventData, block);
+    if (isBlock)
+      return;
+    await event.data.run(...args).catch((err) => {
+      if (onError) {
+        onError(err, eventData);
+        return;
+      }
+      throw err;
+    });
+    if (event.data.once) {
+      this.getEvents(event.data.event)?.delete(event.data.name);
+    }
+  }
+  register(client) {
+    const collection = this.collection.filter((_, key) => key !== "clientReady");
+    for (const [key, events] of collection.entries()) {
+      client.on(key, (...args) => {
+        Promise.all(Array.from(events.values()).map((event) => this.onEvent(event, args)));
+      });
+    }
+  }
+  async runReady(client) {
+    const collection = this.getEvents("clientReady");
+    await Promise.all(Array.from(collection.values()).map((event) => this.onEvent(event, [client])));
+  }
+}
+export {
+  EventManager
+};

package/dist/creators/index.d.ts

@@ -0,0 +1,4 @@
+export { ResponderType, type Responder, type ResponderData, type ResponderInteraction } from "./responders/responder.js";
+export { type Command, type CommandData } from "./commands/command.js";
+export { type Event, type EventData, type EventPropData } from "./events/event.js";
+export * from "./setup.js";

package/dist/creators/index.js

@@ -0,0 +1,9 @@
+// src/creators/index.ts
+import {
+  ResponderType
+} from "./responders/responder.js";
+
+export * from "./setup.js";
+export {
+  ResponderType
+};

package/dist/creators/manager.d.ts

@@ -0,0 +1,6 @@
+import type { ConstaticApp } from "../app.js";
+export declare abstract class BaseManager {
+    readonly logs: string[];
+    readonly app: ConstaticApp;
+    constructor(app: ConstaticApp);
+}

package/dist/creators/manager.js

@@ -0,0 +1,12 @@
+// src/creators/manager.ts
+class BaseManager {
+  logs;
+  app;
+  constructor(app) {
+    this.app = app;
+    this.logs = [];
+  }
+}
+export {
+  BaseManager
+};

package/dist/creators/responders/manager.d.ts

@@ -0,0 +1,13 @@
+import type { CacheType, MessageComponentInteraction, ModalSubmitInteraction } from "discord.js";
+import { BaseManager } from "../manager.js";
+import { ResponderType, type Responder } from "./responder.js";
+export type GenericResponder = Responder<string, readonly ResponderType[], any, CacheType>;
+export type GenericResponderInteraction = MessageComponentInteraction | ModalSubmitInteraction;
+export declare class ResponderManager extends BaseManager {
+    private get config();
+    private readonly router;
+    set(responder: GenericResponder): void;
+    getHandler(type: ResponderType, customId: string): import("rou3").MatchedRoute<GenericResponder> | undefined;
+    private getType;
+    onResponder(interaction: GenericResponderInteraction): Promise<void>;
+}

package/dist/creators/responders/manager.js

@@ -0,0 +1,61 @@
+// src/creators/responders/manager.ts
+import { styleText } from "node:util";
+import { Router } from "../../utils/router.js";
+import { BaseManager } from "../manager.js";
+import { ResponderType } from "./responder.js";
+
+class ResponderManager extends BaseManager {
+  get config() {
+    return this.app.config.responders;
+  }
+  router = new Router;
+  set(responder) {
+    const path = responder.data.customId;
+    for (const type of new Set(responder.data.types)) {
+      this.router.add(type, path, responder);
+      this.logs.push([
+        styleText("greenBright", `▸ ${type}`),
+        styleText("gray", `>`),
+        styleText(["blue", "underline"], path),
+        styleText("green", "✓")
+      ].join(" "));
+    }
+  }
+  getHandler(type, customId) {
+    return this.router.find(type, customId);
+  }
+  getType(interaction) {
+    return interaction.isButton() ? ResponderType.Button : interaction.isStringSelectMenu() ? ResponderType.StringSelect : interaction.isChannelSelectMenu() ? ResponderType.ChannelSelect : interaction.isRoleSelectMenu() ? ResponderType.RoleSelect : interaction.isUserSelectMenu() ? ResponderType.UserSelect : interaction.isMentionableSelectMenu() ? ResponderType.MentionableSelect : interaction.isModalSubmit() && interaction.isFromMessage() ? ResponderType.ModalComponent : interaction.isModalSubmit() ? ResponderType.Modal : undefined;
+  }
+  async onResponder(interaction) {
+    const { middleware, onError, onNotFound } = this.config;
+    const responderType = this.getType(interaction);
+    if (!responderType) {
+      onNotFound?.(interaction);
+      return;
+    }
+    const handler = this.getHandler(responderType, interaction.customId);
+    if (!handler) {
+      onNotFound?.(interaction);
+      return;
+    }
+    const data = handler.data.data;
+    const params = handler.params && data.parse ? data.parse(handler.params) : handler.params ?? {};
+    let isBlock = false;
+    const block = () => isBlock = true;
+    if (middleware)
+      await middleware(interaction, block, params);
+    if (isBlock)
+      return;
+    await data.run(interaction, params).catch((err) => {
+      if (onError) {
+        onError(err, interaction, params);
+        return;
+      }
+      throw err;
+    });
+  }
+}
+export {
+  ResponderManager
+};

package/dist/creators/responders/responder.d.ts

@@ -0,0 +1,41 @@
+import type { ButtonInteraction, CacheType, ChannelSelectMenuInteraction, MentionableSelectMenuInteraction, ModalMessageModalSubmitInteraction, ModalSubmitInteraction, RoleSelectMenuInteraction, StringSelectMenuInteraction, UserSelectMenuInteraction } from "discord.js";
+import { type InferRouteParams } from "rou3";
+import type { Prettify } from "../../utils/types.js";
+type NotEmptyArray<T> = T extends never[] ? never : T;
+type UniqueArray<T> = T extends readonly [infer X, ...infer Rest] ? InArray<Rest, X> extends true ? ["Encountered value with duplicates:", X] : readonly [X, ...UniqueArray<Rest>] : T;
+type InArray<T, X> = T extends readonly [X, ...infer _Rest] ? true : T extends readonly [X] ? true : T extends readonly [infer _, ...infer Rest] ? InArray<Rest, X> : false;
+export declare enum ResponderType {
+    Button = "button",
+    StringSelect = "select.string",
+    UserSelect = "select.user",
+    RoleSelect = "select.role",
+    ChannelSelect = "select.channel",
+    MentionableSelect = "select.mentionable",
+    Modal = "modal",
+    ModalComponent = "modal.component"
+}
+export type ResponderInteraction<Type extends ResponderType, Cache extends CacheType> = {
+    [ResponderType.Button]: ButtonInteraction<Cache>;
+    [ResponderType.StringSelect]: StringSelectMenuInteraction<Cache>;
+    [ResponderType.UserSelect]: UserSelectMenuInteraction<Cache>;
+    [ResponderType.RoleSelect]: RoleSelectMenuInteraction<Cache>;
+    [ResponderType.ChannelSelect]: ChannelSelectMenuInteraction<Cache>;
+    [ResponderType.MentionableSelect]: MentionableSelectMenuInteraction<Cache>;
+    [ResponderType.Modal]: ModalSubmitInteraction<Cache>;
+    [ResponderType.ModalComponent]: ModalMessageModalSubmitInteraction<Cache>;
+}[Type];
+type ResolveParams<Path extends string, Parsed> = Prettify<Parsed extends {
+    [x: string | number | symbol]: any;
+} ? Parsed : InferRouteParams<Path>>;
+export interface ResponderData<Path extends string, Types extends readonly ResponderType[], out Parsed, Cache extends CacheType> {
+    customId: Path;
+    types: NotEmptyArray<UniqueArray<Types>>;
+    cache?: Cache;
+    parse?(this: void, params: InferRouteParams<Path>): Parsed;
+    run(this: void, interaction: ResponderInteraction<Types[number], Cache>, params: ResolveParams<Path, Parsed>): Promise<void>;
+}
+export declare class Responder<Path extends string, Types extends readonly ResponderType[], out Parsed, Cache extends CacheType> {
+    readonly data: ResponderData<Path, Types, Parsed, Cache>;
+    constructor(data: ResponderData<Path, Types, Parsed, Cache>);
+}
+export {};

package/dist/creators/responders/responder.js

@@ -0,0 +1,23 @@
+// src/creators/responders/responder.ts
+var ResponderType;
+((ResponderType2) => {
+  ResponderType2["Button"] = "button";
+  ResponderType2["StringSelect"] = "select.string";
+  ResponderType2["UserSelect"] = "select.user";
+  ResponderType2["RoleSelect"] = "select.role";
+  ResponderType2["ChannelSelect"] = "select.channel";
+  ResponderType2["MentionableSelect"] = "select.mentionable";
+  ResponderType2["Modal"] = "modal";
+  ResponderType2["ModalComponent"] = "modal.component";
+})(ResponderType ||= {});
+
+class Responder {
+  data;
+  constructor(data) {
+    this.data = data;
+  }
+}
+export {
+  ResponderType,
+  Responder
+};

package/dist/creators/setup.d.ts

@@ -0,0 +1,18 @@
+import type { ApplicationCommandType, CacheType, ClientEvents, PermissionResolvable } from "discord.js";
+import { type BaseCommandsConfig, type BaseEventsConfig, type BaseRespondersConfig } from "../app.js";
+import { Command, type CommandData, type CommandType } from "./commands/command.js";
+import { Event, type EventData } from "./events/event.js";
+import { Responder, type ResponderData, type ResponderType } from "./responders/responder.js";
+interface SetupCreatorsOptions {
+    commands?: BaseCommandsConfig & {
+        defaultMemberPermissions?: PermissionResolvable[];
+    };
+    responders?: Partial<BaseRespondersConfig>;
+    events?: Partial<BaseEventsConfig>;
+}
+export declare function setupCreators(options?: SetupCreatorsOptions): {
+    createCommand<T extends CommandType = ApplicationCommandType.ChatInput, P extends boolean = false, R = void>(data: CommandData<T, P, R>): Command<T, P, R>;
+    createEvent: <EventName extends keyof ClientEvents>(data: EventData<EventName>) => Event<EventName>;
+    createResponder<Path extends string, const Types extends readonly ResponderType[], Parsed, Cache extends CacheType = CacheType>(data: ResponderData<Path, Types, Parsed, Cache>): Responder<Path, Types, Parsed, Cache>;
+};
+export {};

package/dist/creators/setup.js

@@ -0,0 +1,39 @@
+// src/creators/setup.ts
+import { ConstaticApp } from "../app.js";
+import { Command } from "./commands/command.js";
+import { Event } from "./events/event.js";
+import { Responder } from "./responders/responder.js";
+function setupCreators(options = {}) {
+  const app = ConstaticApp.getInstance();
+  app.config.commands = { ...options.commands ??= {} };
+  app.config.commands.guilds ??= [];
+  if (process.env.GUILD_ID?.length) {
+    app.config.commands.guilds.push(process.env.GUILD_ID);
+  }
+  return {
+    createCommand(data) {
+      if (options.commands?.defaultMemberPermissions) {
+        data.defaultMemberPermissions ??= options.commands.defaultMemberPermissions;
+      }
+      const command = new Command(data);
+      app.commands.set(command);
+      return command;
+    },
+    createEvent: function(data) {
+      if (data.event === "clientReady") {
+        data.once = true;
+      }
+      const event = new Event(data);
+      app.events.add(event);
+      return event;
+    },
+    createResponder(data) {
+      const responder = new Responder(data);
+      app.responders.set(responder);
+      return responder;
+    }
+  };
+}
+export {
+  setupCreators
+};

package/dist/error.d.ts

@@ -0,0 +1,7 @@
+import { Client } from "discord.js";
+export declare class ConstaticError extends Error {
+    constructor(message: string);
+}
+export declare class RunBlockError {
+}
+export declare function baseErrorHandler(error: any, client?: Client): Promise<void>;

package/dist/error.js

@@ -0,0 +1,64 @@
+// src/error.ts
+import { codeBlock, TextDisplayBuilder, time, WebhookClient } from "discord.js";
+import console from "node:console";
+import { styleText } from "node:util";
+
+class ConstaticError extends Error {
+  constructor(message) {
+    super(message);
+  }
+}
+
+class RunBlockError {
+}
+async function baseErrorHandler(error, client) {
+  if (client?.user)
+    console.log(client.user.displayName);
+  const text = [];
+  const hightlight = (text2) => text2.replace(/\(([^)]+)\)/g, (_, match) => [
+    styleText("gray", "("),
+    styleText("cyan", match),
+    styleText("gray", ")")
+  ].join(""));
+  if ("message" in error)
+    text.push(styleText("red", `${error.message}`));
+  if ("stack" in error) {
+    const formated = `${error.stack}`.replaceAll(process.cwd(), ".").replaceAll("at ", styleText("gray", "at "));
+    text.push(hightlight(formated));
+  }
+  console.log(text.join(`
+`));
+  const url = process.env.WEBHOOK_LOGS_URL;
+  if (!url)
+    return;
+  try {
+    const webhook = new WebhookClient({ url });
+    const username = client?.user?.username;
+    await webhook.send({
+      flags: ["IsComponentsV2"],
+      components: [
+        new TextDisplayBuilder({
+          content: [
+            codeBlock("ansi", text.join(`
+`)),
+            time(new Date, "R")
+          ].join(`
+`)
+        })
+      ],
+      withComponents: true,
+      avatarURL: client?.user?.displayAvatarURL({ size: 512 }),
+      username: username ? `${username} logs` : "Logs"
+    }).catch(console.error);
+  } catch {
+    console.log();
+    console.error("ENV VAR → %s Invalid webhook url", styleText(["bold", "underline"], "WEBHOOK_LOGS_URL"));
+    console.log();
+    console.warn("Unable to send logs to webhook because the url is invalid");
+  }
+}
+export {
+  baseErrorHandler,
+  RunBlockError,
+  ConstaticError
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export declare const version: string;
+export * from "./bootstrap.js";
+export * from "./creators/index.js";

package/dist/index.js

@@ -0,0 +1,9 @@
+// src/index.ts
+import pkg from "../package.json";
+
+export * from "./bootstrap.js";
+export * from "./creators/index.js";
+var version = pkg.version;
+export {
+  version
+};

package/dist/modules.d.ts

@@ -0,0 +1,4 @@
+export declare function loadModules(meta: ImportMeta, modules?: string[]): Promise<{
+    module: any;
+    filepath: string;
+}[]>;

package/dist/modules.js

@@ -0,0 +1,14 @@
+// src/modules.ts
+import { glob } from "node:fs/promises";
+async function loadModules(meta, modules = []) {
+  const exclude = modules.filter((path) => path.startsWith("!")).map((path) => path.slice(1));
+  const filepaths = await Array.fromAsync(glob(modules, { cwd: meta.dirname, exclude }));
+  const promises = filepaths.map((filepath) => import(meta.resolve(filepath)).then((imported) => ({
+    module: imported,
+    filepath
+  })));
+  return Promise.all(promises);
+}
+export {
+  loadModules
+};

package/dist/register.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/register.js

@@ -0,0 +1,21 @@
+// src/register.ts
+import { ConstaticApp } from "./app.js";
+async function registerCommands(client) {
+  const app = ConstaticApp.getInstance();
+  const guildList = new Set(app.config.commands.guilds);
+  const commands = app.commands.build();
+  const promises = [];
+  const manager = client.application.commands;
+  if (guildList.size >= 1) {
+    const globalCommands = commands.filter((c) => c.global);
+    const guildCommands = commands.filter((c) => !c.global);
+    for (const id of guildList.values()) {
+      promises.push(manager.set(guildCommands, id));
+    }
+    promises.push(manager.set(globalCommands));
+  }
+  await Promise.all(promises).then(console.log);
+}
+export {
+  registerCommands
+};

package/dist/utils/router.d.ts

@@ -0,0 +1,9 @@
+import { type MatchedRoute } from "rou3";
+export declare class Router<T> {
+    private router;
+    constructor();
+    add(method: string, path: string, data?: T): void;
+    find(method: string, path: string): MatchedRoute<T> | undefined;
+    remove(method: string, path: string): void;
+    private resolvePath;
+}

package/dist/utils/router.js

@@ -0,0 +1,24 @@
+// src/utils/router.ts
+import { addRoute, createRouter, findRoute, removeRoute } from "rou3";
+
+class Router {
+  router;
+  constructor() {
+    this.router = createRouter();
+  }
+  add(method, path, data) {
+    addRoute(this.router, method.toUpperCase(), this.resolvePath(path), data);
+  }
+  find(method, path) {
+    return findRoute(this.router, method.toUpperCase(), this.resolvePath(path));
+  }
+  remove(method, path) {
+    removeRoute(this.router, method.toUpperCase(), this.resolvePath(path));
+  }
+  resolvePath(path) {
+    return path.startsWith("/") ? path : `/${path}`;
+  }
+}
+export {
+  Router
+};

package/dist/utils/types.d.ts

@@ -0,0 +1,3 @@
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@constatic/base",
+  "version": "0.0.1-beta.1",
+  "description": "",
+  "license": "MIT",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rinckodev/constatic",
+    "directory": "packages/base"
+  },
+  "author": {
+    "url": "https://github.com/rinckodev",
+    "name": "Rincko dev"
+  },
+  "devDependencies": {
+    "@constatic/config": "*",
+    "typescript": "^5.9.3"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "homepage": "https://constatic-docs.vercel.app",
+  "imports": {
+    "#package": [
+      "./src/index.ts"
+    ]
+  },
+  "scripts": {
+    "typegen": "tsc",
+    "build": "bun run ./build.ts",
+    "dev": "bun run ./playground/index.ts"
+  },
+  "peerDependencies": {
+    "discord.js": "^14.24.2"
+  },
+  "dependencies": {
+    "@discordjs/core": "^2.3.0",
+    "rou3": "^0.7.10"
+  }
+}