@arox/framework 0.1.0-alpha.1 → 0.1.0

package/dist/context.d.ts

@@ -0,0 +1,4 @@
+import { Client } from "./structures/Client";
+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,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _discord = require("discord.js");
+const _Event = require("../structures/Event");
+const _Context = require("../structures/Context");
+new _Event.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.",
+            ephemeral: true
+        });
+        return;
+    }
+    try {
+        const ctx = new _Context.Context(context.client, {
+            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!",
+                ephemeral: true
+            });
+        } else {
+            await interaction.reply({
+                content: "There was an error while executing this command!",
+                ephemeral: true
+            });
+        }
+    }
+});

package/dist/events/message.d.ts

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

package/dist/events/message.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _discord = require("discord.js");
+const _Event = require("../structures/Event");
+const _Context = require("../structures/Context");
+const _util = require("../utils/util");
+new _Event.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(_util.deleteMessage);
+        return;
+    }
+    try {
+        const ctx = new _Context.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 _Event = require("../structures/Event");
+new _Event.EventBuilder(_discord.Events.ClientReady).onExecute(async function(context) {
+    if (context.client.options.autoRegisterCommands) {
+        await context.client.registerCommands();
+    }
+});

package/dist/index.d.ts

@@ -1 +1,8 @@
+export * from "./structures/Client";
+export * from "./structures/Command";
+export * from "./structures/Context";
+export * from "./structures/Event";
+export * from "./structures/Argument";
+export * from "./utils/logger/Logger";
+export * from "./context";
 export declare const version = "[VI]{{version}}[/VI]";

package/dist/index.js

@@ -1 +1,19 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"version",{enumerable:true,get:function(){return version}});const version="v0.1.0-alpha.1";
+"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/Client"), exports);
+_export_star._(require("./structures/Command"), exports);
+_export_star._(require("./structures/Context"), exports);
+_export_star._(require("./structures/Event"), exports);
+_export_star._(require("./structures/Argument"), exports);
+_export_star._(require("./utils/logger/Logger"), exports);
+_export_star._(require("./context"), exports);
+const version = "v0.1.0";

package/dist/structures/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/Argument.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Argument", {
+    enumerable: true,
+    get: function() {
+        return Argument;
+    }
+});
+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() {
+        return {
+            name: this.name,
+            description: this.description,
+            type: this.type,
+            required: this.required,
+            choices: this.choices
+        };
+    }
+}

package/dist/structures/Client.d.ts

@@ -0,0 +1,17 @@
+import { Client as DiscordClient, Collection, IntentsBitField } from "discord.js";
+import { CommandBuilder } from "./Command";
+import { FrameworkOptions } from "#types/client.js";
+import { Logger } from "../utils/logger/Logger";
+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;
+    options: Omit<FrameworkOptions, "intents"> & {
+        intents: IntentsBitField;
+    };
+    constructor(opts: FrameworkOptions);
+    loadFiles(dir: string): Promise<void>;
+    loadFile(file: string): Promise<void>;
+    registerCommands(): Promise<void>;
+}

package/dist/structures/Client.js

@@ -0,0 +1,99 @@
+"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 _Files = require("../utils/Files");
+const _lodash = require("lodash");
+const _context = require("../context");
+const _util = require("../utils/util");
+const _Logger = require("../utils/logger/Logger");
+const defaultOpts = {
+    paths: {
+        events: "events",
+        commands: "commands"
+    },
+    autoRegisterCommands: true
+};
+class Client extends _discord.Client {
+    logger;
+    commands;
+    aliases;
+    prefix;
+    constructor(opts){
+        super((0, _lodash.merge)({}, defaultOpts, opts));
+        this.logger = new _Logger.Logger(opts.logger);
+        this.commands = new _discord.Collection();
+        this.aliases = new _discord.Collection();
+        this.prefix = (0, _util.getPrefix)(this.options.prefix ?? {
+            enabled: false
+        });
+        if (this.options.paths?.events) {
+            this.loadFiles(_path.default.join((0, _Files.getProjectRoot)(), this.options.paths?.events)).catch((error)=>this.logger.error("Error loading events:", error));
+        }
+        (0, _context.setClient)(this);
+        try {
+            require("../events/ready");
+            require("../events/interaction");
+            if (this.prefix) require("../events/message");
+        } finally{
+            (0, _context.clearClient)();
+        }
+    }
+    async loadFiles(dir) {
+        if (!require("fs").existsSync(dir)) {
+            this.logger.warn(`Directory not found: ${dir}`);
+            return;
+        }
+        const files = (0, _Files.getFiles)(dir);
+        for (const file of files){
+            await this.loadFile(file);
+        }
+    }
+    async loadFile(file) {
+        try {
+            delete require.cache[require.resolve(file)];
+            (0, _context.setClient)(this);
+            require(file);
+        } catch (error) {
+            this.logger.error(`Error loading file ${file}:`, error);
+        } finally{
+            (0, _context.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/Command.d.ts

@@ -0,0 +1,31 @@
+import { ApplicationCommandOptionData, ChatInputCommandInteraction, Message } from "discord.js";
+import { Context } from "./Context";
+import { Client } from "./Client";
+import { Argument } from "./Argument";
+import { MaybePromise } from "#types/extra.js";
+import { Logger } from "../utils/logger/Logger";
+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: NonNullable<ReturnType<Context<Message>["toJSON"]>>) => MaybePromise<void>;
+    _onInteraction?: (ctx: NonNullable<ReturnType<Context<ChatInputCommandInteraction>["toJSON"]>>) => MaybePromise<void>;
+    get supportsSlash(): false | ((ctx: NonNullable<ReturnType<Context<ChatInputCommandInteraction>["toJSON"]>>) => MaybePromise<void>) | undefined;
+    get supportsPrefix(): false | ((ctx: NonNullable<ReturnType<Context<Message>["toJSON"]>>) => MaybePromise<void>) | undefined;
+    constructor(options: CommandOptions);
+    onMessage(func: (ctx: NonNullable<ReturnType<Context<Message>["toJSON"]>>) => MaybePromise<void>): this;
+    onInteraction(func: (ctx: NonNullable<ReturnType<Context<ChatInputCommandInteraction>["toJSON"]>>) => MaybePromise<void>): this;
+}

package/dist/structures/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 _context = require("../context");
+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 = _context.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/Context.d.ts

@@ -0,0 +1,32 @@
+import { Message, User, ChatInputCommandInteraction } from "discord.js";
+import { Client } from "../structures/Client";
+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;
+    constructor(client: Client, payload: ContextPayload<T>);
+    isInteraction(): this is Context<ChatInputCommandInteraction>;
+    isMessage(): this is Context<Message>;
+    get author(): User | null;
+    toJSON(): {
+        kind: "interaction";
+        interaction: T;
+        author: User | null;
+        message?: undefined;
+        args?: undefined;
+    } | {
+        kind: "message";
+        message: Message;
+        args: string[];
+        author: User | null;
+        interaction?: undefined;
+    };
+}
+export {};

package/dist/structures/Context.js

@@ -0,0 +1,56 @@
+"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;
+    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;
+    }
+    toJSON() {
+        const { data, args, author } = this;
+        if (this.isInteraction()) {
+            return {
+                kind: "interaction",
+                interaction: data,
+                author: author
+            };
+        }
+        return {
+            kind: "message",
+            message: data,
+            args: args,
+            author: author
+        };
+    }
+}

package/dist/structures/Event.d.ts

@@ -0,0 +1,19 @@
+import { ClientEvents } from "discord.js";
+import { MaybePromise } from "#types/extra.js";
+import { Client } from "./Client";
+import { Logger } from "../utils/logger/Logger";
+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/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 _context = require("../context");
+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 (!_context.currentClient) throw new Error("Client is not defined");
+        this.client = _context.currentClient;
+        this.logger = _context.currentClient.logger;
+        if (_handler) {
+            this.handler = _handler;
+            this.register();
+        }
+        this.logger.debug(`Loaded Event ${String(this.name)}`);
+    }
+    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;
+    }
+    onExecute(func) {
+        this.handler = func;
+        this.register();
+        return this;
+    }
+}

package/dist/utils/Files.d.ts

@@ -0,0 +1,2 @@
+export declare function getFiles(baseDir: string): string[];
+export declare function getProjectRoot(): string;

package/dist/utils/Files.js

@@ -0,0 +1,47 @@
+"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 getFiles () {
+        return getFiles;
+    },
+    get getProjectRoot () {
+        return getProjectRoot;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _fastglob = /*#__PURE__*/ _interop_require_default._(require("fast-glob"));
+const _path = /*#__PURE__*/ _interop_require_default._(require("path"));
+function getFiles(baseDir) {
+    return _fastglob.default.sync([
+        "**/*.ts",
+        "**/*.js"
+    ], {
+        cwd: baseDir,
+        absolute: true,
+        ignore: [
+            "**/*.d.ts",
+            "node_modules/**",
+            ".git/**",
+            "dist/**",
+            "lib/**",
+            "out/**",
+            "build/**",
+            ".next/**",
+            "coverage/**"
+        ]
+    });
+}
+function getProjectRoot() {
+    if (!require.main?.filename) {
+        return process.cwd();
+    }
+    return _path.default.dirname(require.main.filename);
+}