@arox/framework 0.1.0-alpha.2 → 0.1.1

package/dist/context.d.ts

@@ -0,0 +1,4 @@
+import { Client } from "#structures";
+export declare let currentClient: Client | null;
+export declare function setClient(client: Client): void;
+export declare function clearClient(): void;

package/dist/context.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get clearClient () {
+        return clearClient;
+    },
+    get currentClient () {
+        return currentClient;
+    },
+    get setClient () {
+        return setClient;
+    }
+});
+let currentClient = null;
+function setClient(client) {
+    currentClient = client;
+}
+function clearClient() {
+    currentClient = null;
+}

package/dist/events/interaction.d.ts

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

package/dist/events/interaction.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _discord = require("discord.js");
+const _structures = require("#structures");
+new _structures.EventBuilder(_discord.Events.InteractionCreate, false).onExecute(async function(context, interaction) {
+    if (!interaction.isChatInputCommand()) return;
+    const command = context.client.commands.get(interaction.commandName);
+    if (!command || !command.supportsSlash) {
+        await interaction.reply({
+            content: "Command not found or disabled.",
+            flags: _discord.MessageFlags.Ephemeral
+        });
+        return;
+    }
+    try {
+        const ctx = new _structures.Context(context.client, {
+            interaction
+        });
+        ctx.locale = interaction.locale;
+        context.logger.debug(`${ctx.author?.tag ?? "Unknown"} used ${command.name}(interaction)`);
+        if (command._onInteraction) await command._onInteraction(ctx.toJSON());
+    } catch (error) {
+        context.client.logger.error(`Error executing command ${command.name}:`, error);
+        if (interaction.replied || interaction.deferred) {
+            await interaction.followUp({
+                content: "There was an error while executing this command!",
+                flags: _discord.MessageFlags.Ephemeral
+            });
+        } else {
+            await interaction.reply({
+                content: "There was an error while executing this command!",
+                flags: _discord.MessageFlags.Ephemeral
+            });
+        }
+    }
+});

package/dist/events/message.d.ts

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

package/dist/events/message.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _discord = require("discord.js");
+const _structures = require("#structures");
+const _utils = require("#utils");
+new _structures.EventBuilder(_discord.Events.MessageCreate, false, async function(context, message) {
+    if (message.author.bot) return;
+    const prefix = context.client.prefix;
+    if (typeof prefix !== "string" || prefix.length === 0 || !message.content.startsWith(prefix)) return;
+    const args = message.content.slice(prefix.length).trim().split(/ +/);
+    const commandName = args.shift()?.toLowerCase();
+    if (!commandName) return;
+    const commandAlias = context.client.aliases.findKey((cmd)=>cmd.has(commandName));
+    let command = context.client.commands.get(commandAlias ?? commandName);
+    if (!command || !command.supportsPrefix) {
+        await message.reply({
+            content: "Command not found or disabled.",
+            allowedMentions: {
+                repliedUser: false
+            }
+        }).then(_utils.deleteMessageAfterSent);
+        return;
+    }
+    try {
+        const ctx = new _structures.Context(context.client, {
+            message,
+            args
+        });
+        context.logger.debug(`${ctx.author?.tag ?? "Unknown"} used ${command.name}(message)`);
+        if (command._onMessage) await command._onMessage(ctx.toJSON());
+    } catch (error) {
+        context.client.logger.error(`Error executing command ${command.name}:`, error);
+    }
+});

package/dist/events/ready.d.ts

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

package/dist/events/ready.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _discord = require("discord.js");
+const _structures = require("#structures");
+new _structures.EventBuilder(_discord.Events.ClientReady).onExecute(async function(context) {
+    if (context.client.options.autoRegisterCommands) {
+        await context.client.registerCommands();
+    }
+});

package/dist/index.d.ts

@@ -1 +1,4 @@
+export * from "#structures";
+export * from "./utils/logger/Logger";
+export * from "#ctx";
 export declare const version = "[VI]{{version}}[/VI]";

package/dist/index.js

@@ -1 +1,15 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"version",{enumerable:true,get:function(){return version}});const version="v0.1.0-alpha.2";
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "version", {
+    enumerable: true,
+    get: function() {
+        return version;
+    }
+});
+const _export_star = require("@swc/helpers/_/_export_star");
+_export_star._(require("#structures"), exports);
+_export_star._(require("./utils/logger/Logger"), exports);
+_export_star._(require("#ctx"), exports);
+const version = "v0.1.1";

package/dist/structures/builder/Argument.d.ts

@@ -0,0 +1,22 @@
+import { ApplicationCommandOptionData, ApplicationCommandOptionType } from "discord.js";
+export declare class Argument {
+    readonly name: string;
+    readonly description: string;
+    readonly type: ApplicationCommandOptionType;
+    readonly required: boolean;
+    readonly choices?: {
+        name: string;
+        value: string | number;
+    }[];
+    constructor(data: {
+        name: string;
+        description: string;
+        type: ApplicationCommandOptionType;
+        required?: boolean;
+        choices?: {
+            name: string;
+            value: string | number;
+        }[];
+    });
+    toJSON(): ApplicationCommandOptionData;
+}

package/dist/structures/builder/Argument.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Argument", {
+    enumerable: true,
+    get: function() {
+        return Argument;
+    }
+});
+const _discord = require("discord.js");
+class Argument {
+    name;
+    description;
+    type;
+    required;
+    choices;
+    constructor(data){
+        this.name = data.name;
+        this.description = data.description;
+        this.type = data.type;
+        this.required = data.required ?? false;
+        this.choices = data.choices;
+    }
+    toJSON() {
+        const choicesAllowedTypes = [
+            _discord.ApplicationCommandOptionType.String,
+            _discord.ApplicationCommandOptionType.Integer,
+            _discord.ApplicationCommandOptionType.Number
+        ];
+        if (this.choices && !choicesAllowedTypes.includes(this.type)) {
+            throw new Error(`Choices are not allowed for option type ${_discord.ApplicationCommandOptionType[this.type]} (${this.type})`);
+        }
+        return {
+            name: this.name,
+            description: this.description,
+            type: this.type,
+            required: this.required,
+            choices: this.choices
+        };
+    }
+}

package/dist/structures/builder/Command.d.ts

@@ -0,0 +1,33 @@
+import { ApplicationCommandOptionData, ChatInputCommandInteraction, Message } from "discord.js";
+import { Context, Client } from "#structures";
+import { Argument } from "./Argument";
+import { MaybePromise } from "#types/extra.js";
+import { Logger } from "#utils";
+type MessageContext = NonNullable<ReturnType<Context<Message>["toJSON"]>>;
+type InteractionContext = NonNullable<ReturnType<Context<ChatInputCommandInteraction>["toJSON"]>>;
+export interface CommandOptions {
+    name: string;
+    description: string;
+    aliases?: string[];
+    options?: (ApplicationCommandOptionData | Argument)[];
+    slash?: boolean;
+    prefix?: boolean;
+}
+export declare class CommandBuilder {
+    readonly client: Client;
+    readonly logger: Logger;
+    readonly name: string;
+    readonly description: string;
+    readonly aliases: string[];
+    readonly options: ApplicationCommandOptionData[];
+    private _supportsSlash;
+    private _supportsPrefix;
+    _onMessage?: (ctx: MessageContext) => MaybePromise<void>;
+    _onInteraction?: (ctx: InteractionContext) => MaybePromise<void>;
+    get supportsSlash(): false | ((ctx: InteractionContext) => MaybePromise<void>) | undefined;
+    get supportsPrefix(): false | ((ctx: MessageContext) => MaybePromise<void>) | undefined;
+    constructor(options: CommandOptions);
+    onMessage(func: (ctx: MessageContext) => MaybePromise<void>): this;
+    onInteraction(func: (ctx: InteractionContext) => MaybePromise<void>): this;
+}
+export {};

package/dist/structures/builder/Command.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "CommandBuilder", {
+    enumerable: true,
+    get: function() {
+        return CommandBuilder;
+    }
+});
+const _Argument = require("./Argument");
+const _ctx = require("#ctx");
+class CommandBuilder {
+    client;
+    logger;
+    name;
+    description;
+    aliases;
+    options;
+    _supportsSlash;
+    _supportsPrefix;
+    _onMessage;
+    _onInteraction;
+    get supportsSlash() {
+        return this._supportsSlash && this._onInteraction;
+    }
+    get supportsPrefix() {
+        return this._supportsPrefix && this._onMessage;
+    }
+    constructor(options){
+        const client = _ctx.currentClient;
+        if (!client) throw new Error("Client is not defined");
+        this.client = client;
+        this.logger = client.logger;
+        this.name = options.name;
+        this.description = options.description;
+        this.aliases = options.aliases ?? [];
+        this.options = (options.options ?? []).map((opt)=>{
+            return opt instanceof _Argument.Argument ? opt.toJSON() : opt;
+        });
+        this._supportsPrefix = options.prefix ?? false;
+        this._supportsSlash = options.slash ?? false;
+        if (!this._supportsPrefix && !this._supportsSlash) {
+            throw new Error(`Command ${this.name} must support either slash or prefix commands.`);
+        }
+        if (this.client.commands.has(this.name)) throw new Error(`Command name "${this.name}" is already registered.`);
+        const existingAliasOwner = this.client.aliases.findKey((aliases)=>aliases.has(this.name));
+        if (existingAliasOwner) {
+            throw new Error(`Command name "${this.name}" is already registered as an alias for command "${existingAliasOwner}".`);
+        }
+        for (const alias of this.aliases){
+            if (this.client.commands.has(alias)) {
+                throw new Error(`Alias "${alias}" is already registered as a command name.`);
+            }
+            const conflictingCommand = this.client.aliases.findKey((aliases)=>aliases.has(alias));
+            if (conflictingCommand) {
+                throw new Error(`Alias "${alias}" is already registered as an alias for command "${conflictingCommand}".`);
+            }
+        }
+        this.client.commands.set(this.name, this);
+        if (this.aliases.length > 0) {
+            this.client.aliases.set(this.name, new Set(this.aliases));
+        }
+        this.logger.debug(`Loaded Command ${this.name}`);
+    }
+    onMessage(func) {
+        this._onMessage = func;
+        return this;
+    }
+    onInteraction(func) {
+        this._onInteraction = func;
+        return this;
+    }
+}

package/dist/structures/builder/Context.d.ts

@@ -0,0 +1,36 @@
+import { Message, User, ChatInputCommandInteraction, Locale } from "discord.js";
+import { Client } from "#structures";
+type ContextPayload<T extends ChatInputCommandInteraction | Message> = T extends ChatInputCommandInteraction ? {
+    interaction: T;
+    args?: string[];
+} : {
+    message: T;
+    args?: string[];
+};
+export declare class Context<T extends ChatInputCommandInteraction | Message> {
+    readonly client: Client;
+    readonly args: string[];
+    readonly data: T;
+    locale?: `${Locale}`;
+    constructor(client: Client, payload: ContextPayload<T>);
+    isInteraction(): this is Context<ChatInputCommandInteraction>;
+    isMessage(): this is Context<Message>;
+    get author(): User | null;
+    t(key: string, args?: Record<string, any>): string;
+    toJSON(): {
+        kind: "interaction";
+        interaction: T;
+        author: User | null;
+        t: any;
+        message?: undefined;
+        args?: undefined;
+    } | {
+        kind: "message";
+        message: Message;
+        args: string[];
+        author: User | null;
+        t: any;
+        interaction?: undefined;
+    };
+}
+export {};

package/dist/structures/builder/Context.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Context", {
+    enumerable: true,
+    get: function() {
+        return Context;
+    }
+});
+const _discord = require("discord.js");
+class Context {
+    client;
+    args;
+    data;
+    locale;
+    constructor(client, payload){
+        this.client = client;
+        this.args = payload.args ?? [];
+        if ("interaction" in payload) {
+            this.data = payload.interaction;
+        } else {
+            this.data = payload.message;
+        }
+    }
+    isInteraction() {
+        return this.data instanceof _discord.ChatInputCommandInteraction;
+    }
+    isMessage() {
+        return this.data instanceof _discord.Message;
+    }
+    get author() {
+        if (this.isInteraction()) {
+            return this.data.user;
+        }
+        if (this.isMessage()) {
+            return this.data.author;
+        }
+        return null;
+    }
+    t(key, args) {
+        if (!this.client.i18n) {
+            throw new Error("i18n is not initialized");
+        }
+        let locale = this.locale ?? (Array.isArray(this.client.i18n.options.fallbackLng) ? this.client.i18n.options.fallbackLng[0] : this.client.i18n.options.fallbackLng) ?? "en";
+        const t = this.client.i18n.getFixedT(locale);
+        return t(key, args);
+    }
+    toJSON() {
+        const { data, args, author } = this;
+        if (this.isInteraction()) {
+            return {
+                kind: "interaction",
+                interaction: data,
+                author,
+                t: this.t.bind(this)
+            };
+        }
+        return {
+            kind: "message",
+            message: data,
+            args,
+            author,
+            t: this.t.bind(this)
+        };
+    }
+}

package/dist/structures/builder/Event.d.ts

@@ -0,0 +1,19 @@
+import { ClientEvents } from "discord.js";
+import { MaybePromise } from "#types/extra.js";
+import { Client } from "#structures";
+import { Logger } from "#utils";
+type EventArgs<K extends keyof ClientEvents> = ClientEvents[K];
+type EventHandler<K extends keyof ClientEvents> = (context: EventBuilder<K>, ...args: EventArgs<K>) => MaybePromise<void>;
+export declare class EventBuilder<K extends keyof ClientEvents> {
+    readonly name: K;
+    readonly once: boolean;
+    readonly client: Client;
+    readonly logger: Logger;
+    private handler?;
+    private bound;
+    private readonly listener;
+    constructor(name: K, once?: boolean, _handler?: EventHandler<K>);
+    private register;
+    onExecute(func: EventHandler<K>): this;
+}
+export {};

package/dist/structures/builder/Event.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "EventBuilder", {
+    enumerable: true,
+    get: function() {
+        return EventBuilder;
+    }
+});
+const _ctx = require("#ctx");
+class EventBuilder {
+    name;
+    once;
+    client;
+    logger;
+    handler;
+    bound = false;
+    listener = async (...args)=>{
+        if (!this.handler) return;
+        try {
+            await this.handler(this, ...args);
+        } catch (error) {
+            this.client.logger.error(`Error executing event ${this.name} (${this.constructor.name}):`, error);
+        }
+    };
+    constructor(name, once = false, _handler){
+        this.name = name;
+        this.once = once;
+        if (!_ctx.currentClient) throw new Error("Client is not defined");
+        this.client = _ctx.currentClient;
+        this.logger = _ctx.currentClient.logger;
+        if (_handler) {
+            this.handler = _handler;
+            this.register();
+        }
+    }
+    register() {
+        if (this.bound || !this.handler) return;
+        if (this.once) {
+            this.client.once(this.name, this.listener);
+        } else {
+            this.client.on(this.name, this.listener);
+        }
+        this.bound = true;
+        this.logger.debug(`Loaded Event ${String(this.name)}`);
+    }
+    onExecute(func) {
+        this.handler = func;
+        this.register();
+        return this;
+    }
+}

package/dist/structures/builder/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./Argument";
+export * from "./Command";
+export * from "./Context";
+export * from "./Event";

package/dist/structures/builder/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _export_star = require("@swc/helpers/_/_export_star");
+_export_star._(require("./Argument"), exports);
+_export_star._(require("./Command"), exports);
+_export_star._(require("./Context"), exports);
+_export_star._(require("./Event"), exports);

package/dist/structures/core/Client.d.ts

@@ -0,0 +1,20 @@
+import { Client as DiscordClient, Collection, IntentsBitField } from "discord.js";
+import { CommandBuilder } from "#structures";
+import { Logger } from "#utils";
+import { FrameworkOptions } from "#types/client.js";
+import { i18n } from "i18next";
+export declare class Client<Ready extends boolean = boolean> extends DiscordClient<Ready> {
+    readonly logger: Logger;
+    commands: Collection<string, CommandBuilder>;
+    aliases: Collection<string, Set<string>>;
+    readonly prefix: string | false;
+    i18n: i18n | undefined;
+    options: Omit<FrameworkOptions, "intents"> & {
+        intents: IntentsBitField;
+    };
+    constructor(opts: FrameworkOptions);
+    login(token?: string): Promise<string>;
+    loadDir(dir: string): Promise<void>;
+    loadFile(file: string): Promise<void>;
+    registerCommands(): Promise<void>;
+}

package/dist/structures/core/Client.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Client", {
+    enumerable: true,
+    get: function() {
+        return Client;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _discord = require("discord.js");
+const _path = /*#__PURE__*/ _interop_require_default._(require("path"));
+const _utils = require("#utils");
+const _lodash = require("lodash");
+const _ctx = require("#ctx");
+const _fs = require("fs");
+const defaultOpts = {
+    includePaths: [
+        "events",
+        "commands"
+    ],
+    autoRegisterCommands: true
+};
+class Client extends _discord.Client {
+    logger;
+    commands;
+    aliases;
+    prefix;
+    i18n;
+    constructor(opts){
+        super((0, _lodash.merge)({}, defaultOpts, opts));
+        this.logger = new _utils.Logger(opts.logger);
+        this.commands = new _discord.Collection();
+        this.aliases = new _discord.Collection();
+        this.prefix = (0, _utils.getPrefix)(this.options.prefix ?? {
+            enabled: false
+        });
+        if (this.options.i18n) {
+            this.i18n = this.options.i18n;
+            this.i18n.use(new _utils.I18nLoggerAdapter(this.logger));
+        }
+        (0, _ctx.setClient)(this);
+        try {
+            require("../events/ready");
+            require("../events/interaction");
+            if (this.prefix) require("../events/message");
+        } finally{
+            (0, _ctx.clearClient)();
+        }
+    }
+    async login(token) {
+        if (this.options.includePaths) {
+            for (const p of this.options.includePaths){
+                this.loadDir(_path.default.join((0, _utils.getProjectRoot)(), p)).catch((error)=>this.logger.error("Error loading events:", error));
+            }
+        }
+        if (this.i18n && !this.i18n.isInitialized) {
+            await this.i18n.init();
+        }
+        return super.login(token);
+    }
+    async loadDir(dir) {
+        if (!(0, _fs.existsSync)(dir)) {
+            this.logger.debug(`Directory not found: ${dir}`);
+            return;
+        }
+        const files = (0, _utils.getFiles)(dir);
+        for (const file of files){
+            await this.loadFile(file);
+        }
+    }
+    async loadFile(file) {
+        try {
+            delete require.cache[require.resolve(file)];
+            (0, _ctx.setClient)(this);
+            require(file);
+        } catch (error) {
+            this.logger.error(`Error loading file ${file}:`, error);
+        } finally{
+            (0, _ctx.clearClient)();
+        }
+    }
+    async registerCommands() {
+        if (!this.token) {
+            this.logger.warn("registerCommands skipped: client token is not set.");
+            return;
+        }
+        if (!this.application) {
+            this.logger.warn("registerCommands skipped: client application is not ready.");
+            return;
+        }
+        const slashCommands = this.commands.filter((cmd)=>cmd.supportsSlash).map((cmd)=>({
+                name: cmd.name,
+                description: cmd.description,
+                options: cmd.options
+            }));
+        const rest = new _discord.REST({
+            version: "10"
+        }).setToken(this.token);
+        try {
+            this.logger.debug(`Started refreshing ${slashCommands.length} application (/) commands.`);
+            await rest.put(_discord.Routes.applicationCommands(this.application.id), {
+                body: slashCommands
+            });
+            this.logger.info(`Loaded ${slashCommands.length} application (/) commands.`);
+        } catch (error) {
+            this.logger.error("Failed to register commands:", error);
+        }
+    }
+}

package/dist/structures/core/index.d.ts

@@ -0,0 +1 @@
+export * from "./Client";

package/dist/structures/core/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _export_star = require("@swc/helpers/_/_export_star");
+_export_star._(require("./Client"), exports);

package/dist/structures/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./core";
+export * from "./builder";