command-ts 0.0.1 → 0.0.2-dev.20260105052257

package/out/index.d.ts

@@ -1 +1,4 @@
-export {};
+export { version } from "../package.json";
+export * from "./function";
+export * from "./handler";
+export * from "./type";

package/out/index.js

@@ -1,3 +1,22 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-console.log("Hello, world!");
+exports.version = void 0;
+var package_json_1 = require("../package.json");
+Object.defineProperty(exports, "version", { enumerable: true, get: function () { return package_json_1.version; } });
+__exportStar(require("./function"), exports);
+__exportStar(require("./handler"), exports);
+__exportStar(require("./type"), exports);

package/out/type.d.ts

@@ -0,0 +1,26 @@
+import { AutocompleteInteraction, ChannelSelectMenuInteraction, ChatInputCommandInteraction, Client, ClientEvents, ContextMenuCommandInteraction, MentionableSelectMenuInteraction, RESTPostAPIApplicationCommandsJSONBody, RoleSelectMenuInteraction, StringSelectMenuInteraction, UserSelectMenuInteraction, ModalSubmitInteraction, ButtonInteraction, CommandInteraction, PrimaryEntryPointCommandInteraction } from "discord.js";
+export type Options = {
+    client: Client;
+    debug?: boolean;
+    event?: PathOR<keyof ClientEvents, ((...arg: any) => any) | Array<(...arg: any) => any>>;
+    command?: PathOR<string, Command>;
+    button?: PathOR<string, (interaction: ButtonInteraction) => any>;
+    modal?: PathOR<string, (interaction: ModalSubmitInteraction) => any>;
+    selectmenu?: SelectMenu | string;
+    middleware?: Array<Middleware> | Middleware;
+};
+export type SelectMenu = {
+    StringSelectMenu?: PathOR<string, (interaction: StringSelectMenuInteraction) => any>;
+    UserSelectMenu?: PathOR<string, (interaction: UserSelectMenuInteraction) => any>;
+    RoleSelectMenu?: PathOR<string, (interaction: RoleSelectMenuInteraction) => any>;
+    MentionableSelectMenu?: PathOR<string, (interaction: MentionableSelectMenuInteraction) => any>;
+    ChannelSelectMenu?: PathOR<string, (interaction: ChannelSelectMenuInteraction) => any>;
+};
+export type PathOR<key extends string, value extends any> = Map<key, value> | string;
+export type StopFunction = (reason?: string) => void;
+export type Command = {
+    data: RESTPostAPIApplicationCommandsJSONBody;
+    autocomplete?: (interaction: AutocompleteInteraction) => any;
+    run: (interaction: ChatInputCommandInteraction | ContextMenuCommandInteraction | PrimaryEntryPointCommandInteraction) => any;
+};
+export type Middleware = (command: Command, interaction: CommandInteraction, stop: StopFunction) => any;

package/out/type.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+export type Handler = {
+    events?: string
+    commands?: string | CommandHandler
+    components?: string | ComponentHandler
+}
+
+export type CommandHandler = {
+    ChatInput?: string
+    Context?: string
+}
+
+export type ComponentHandler = {
+    Button?: string
+    Modal?: string
+    SelectMenu?: string | SelectMenuComponentHandler
+}
+
+export type SelectMenuComponentHandler = {
+    StringSelectMenu?: string
+    UserSelectMenu?: string
+    RoleSelectMenu?: string
+    MentionableSelectMenu?: string
+    ChannelSelectMenu?: string
+}
+*/

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "command-ts",
-  "version": "0.0.1",
+  "version": "0.0.2-dev.20260105052257",
   "description": "A package for handling discord.js commands with TypeScript.",
-  "author": "softwarexplus",
-  "homepage": "https://github.com/softwarexplus/command-ts#readme",
+  "author": "xcfio",
+  "homepage": "https://github.com/xcfio/command-ts#readme",
   "main": "out/index.js",
   "license": "MIT",
   "keywords": [
@@ -13,26 +13,33 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/softwarexplus/command-ts"
+    "url": "https://github.com/xcfio/command-ts"
   },
   "bugs": {
-    "url": "https://github.com/softwarexplus/command-ts/issues",
-    "email": "SoftwareXPlus@gmail.com"
+    "url": "https://github.com/xcfio/command-ts/issues",
+    "email": "omarfaruksxp@gmail.com"
   },
   "funding": {
     "type": "patreon",
-    "url": "https://www.patreon.com/SoftwareXPlus"
+    "url": "https://www.patreon.com/xcfio"
   },
   "publishConfig": {
     "access": "public",
     "tag": "latest"
   },
+  "dependencies": {
+    "colorette": "^2.0.20",
+    "lodash": "^4.17.21"
+  },
   "devDependencies": {
-    "@types/node": "^22.5.4"
+    "@types/lodash": "^4.17.14",
+    "@types/node": "^25.0.0",
+    "discord.js": "^14.17.2",
+    "typescript": "^5.7.2"
   },
   "scripts": {
-    "fmt": "prettier --config=.prettierrc --write src/",
-    "lint": "prettier --config=.prettierrc --check src/",
+    "fmt": "prettier --config=../../.prettierrc --write src/",
+    "lint": "prettier --config=../../.prettierrc --check src/",
     "build": "(node --eval \"require('node:fs').rmSync('out', { recursive: true, force: true })\" || true) && tsc",
     "test": "tsc --noEmit",
     "dev": "tsc --watch"

package/src/function/CTSError.ts

@@ -0,0 +1,6 @@
+export class CTSError extends Error {
+    constructor(message: string) {
+        super(message)
+        this.name = "CTSError"
+    }
+}

package/src/function/debug.ts

@@ -0,0 +1,97 @@
+import { blue, green, yellow, red, gray } from "colorette"
+import { IsDebugEnabled } from "../handler"
+import { inspect } from "node:util"
+
+export const enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3
+}
+
+type LoggerConfig = {
+    minLevel: LogLevel
+    includeTimestamp: boolean
+    dateFormat: Intl.DateTimeFormatOptions
+    timeFormat: Intl.DateTimeFormatOptions
+}
+
+const defaultConfig: LoggerConfig = {
+    minLevel: LogLevel.DEBUG,
+    includeTimestamp: true,
+    dateFormat: {
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit"
+    },
+    timeFormat: {
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: false
+    }
+}
+
+const getTimestamp = (config: LoggerConfig): string => {
+    if (!config.includeTimestamp) return ""
+
+    const date = new Date()
+    const dateStr = date.toLocaleDateString(undefined, config.dateFormat)
+    const timeStr = date.toLocaleTimeString(undefined, config.timeFormat)
+    return `[${dateStr} ${timeStr}]`
+}
+
+const shouldLog = (level: string, config: LoggerConfig): boolean => {
+    const levelMap: Record<string, LogLevel> = {
+        DEBUG: LogLevel.DEBUG,
+        INFO: LogLevel.INFO,
+        WARN: LogLevel.WARN,
+        ERROR: LogLevel.ERROR
+    }
+    return levelMap[level] >= config.minLevel
+}
+
+const formatArgs = (args: unknown[]) => {
+    if (args.length === 0) return ""
+    let str = ""
+
+    for (const obj of args) {
+        str += inspect(obj, { colors: true, depth: Infinity })
+        str += " "
+    }
+
+    return str
+}
+
+const createLog = (config: LoggerConfig) => {
+    return (
+        level: keyof typeof LogLevel,
+        color: (str: string) => string,
+        message: unknown,
+        ...args: unknown[]
+    ): void => {
+        if (shouldLog(level, config)) {
+            const timestamp = getTimestamp(config)
+            const levelStr = color(`[${level}]`)
+            const formattedArgs = formatArgs(args)
+
+            if (IsDebugEnabled) console.log(`${blue(timestamp)} ${levelStr} ${message} ${formattedArgs}`)
+            if (level === "WARN") process.emitWarning(`${message}`)
+        }
+    }
+}
+
+const createLogger = (customConfig: Partial<LoggerConfig> = {}) => {
+    const config = { ...defaultConfig, ...customConfig }
+    const log = createLog(config)
+
+    return {
+        debug: (message: unknown, ...args: unknown[]) => log("DEBUG", gray, message, ...args),
+        info: (message: unknown, ...args: unknown[]) => log("INFO", green, message, ...args),
+        warn: (message: unknown, ...args: unknown[]) => log("WARN", yellow, message, ...args),
+        error: (message: unknown, ...args: unknown[]) => log("ERROR", red, message, ...args)
+    }
+}
+
+export const debug = createLogger()
+export { createLogger }

package/src/function/index.ts

@@ -0,0 +1,4 @@
+export * from "./CTSError"
+export * from "./debug"
+export * from "./read-dir"
+export * from "./visual"

package/src/function/read-dir.ts

@@ -0,0 +1,46 @@
+import { readdirSync } from "node:fs"
+import { join } from "node:path"
+
+export function GetFilePaths(directory: string, nesting?: boolean): string[] {
+    let file_paths: string[] = []
+
+    if (!directory) return file_paths
+
+    const files = readdirSync(directory, { withFileTypes: true })
+
+    for (const file of files) {
+        const file_path = join(directory, file.name)
+
+        if (file.isFile()) {
+            file_paths.push(file_path)
+        }
+
+        if (nesting && file.isDirectory()) {
+            file_paths = [...file_paths, ...GetFilePaths(file_path, true)]
+        }
+    }
+
+    return file_paths
+}
+
+export function GetFolderPaths(directory: string, nesting?: boolean): string[] {
+    let folder_paths: string[] = []
+
+    if (!directory) return folder_paths
+
+    const folders = readdirSync(directory, { withFileTypes: true })
+
+    for (const folder of folders) {
+        const folder_path = join(directory, folder.name)
+
+        if (folder.isDirectory()) {
+            folder_paths.push(folder_path)
+
+            if (nesting) {
+                folder_paths = [...folder_paths, ...GetFolderPaths(folder_path, true)]
+            }
+        }
+    }
+
+    return folder_paths
+}

package/src/function/visual.ts

@@ -0,0 +1,69 @@
+import { cyan, magenta } from "colorette"
+import path from "path"
+
+export function GenerateList(type: string, filePaths: string[], srcDir: string): string {
+    const x: string[] = []
+    const commandCount = filePaths.length
+
+    // Create directory structure from file paths
+    const directoryStructure: Record<string, any> = {}
+
+    for (const filePath of filePaths) {
+        // Skip files not in src directory
+        if (!filePath.startsWith(srcDir)) continue
+
+        // Get relative path from src
+        const relativePath = filePath.substring(srcDir.length + 1)
+        const pathParts = relativePath.split(path.sep)
+
+        // File name without extension
+        const fileName = path.basename(pathParts[pathParts.length - 1], ".ts")
+
+        // Build directory structure
+        let currentLevel = directoryStructure
+
+        // Process each directory in the path
+        for (let i = 0; i < pathParts.length - 1; i++) {
+            const part = pathParts[i]
+
+            if (!currentLevel[part]) {
+                currentLevel[part] = { __files: [] }
+            }
+
+            currentLevel = currentLevel[part]
+        }
+
+        // Add file to the current directory
+        currentLevel.__files.push(fileName)
+    }
+
+    // Generate formatted command list from directory structure
+    function processStructure(structure: Record<string, any>, level: number = 0): void {
+        // Process directories first
+        for (const dir in structure) {
+            if (dir === "__files") continue
+
+            const indent = "  ".repeat(level)
+            x.push(`${indent}├─ ${cyan(dir)}`)
+
+            // Process subdirectories and files
+            processStructure(structure[dir], level + 1)
+        }
+
+        // Process files
+        if (structure.__files) {
+            const indent = "  ".repeat(level)
+            for (const file of structure.__files) {
+                x.push(`${indent}├─ ${cyan(file)}`)
+            }
+        }
+    }
+
+    // Generate command list
+    processStructure(directoryStructure)
+
+    // Add summary at the beginning
+    x.unshift(`Loaded ${magenta(commandCount.toString())} ${type}:`)
+
+    return x.join("\n")
+}

package/src/handler/button/index.ts

@@ -0,0 +1,7 @@
+import { Options } from "../../type"
+import { debug } from "../../function"
+import { Client } from "discord.js"
+
+export function button_handler(data: Options["button"], client: Client) {
+    debug.warn("Button handler is not implemented yet")
+}

package/src/handler/command/autocomplete.ts

@@ -0,0 +1,4 @@
+import { Interaction } from "discord.js"
+import { Command } from "../../type"
+
+export async function autocomplete(commands: Map<string, Command>, interaction: Interaction) {}

package/src/handler/command/execute.ts

@@ -0,0 +1,48 @@
+import { Command, Middleware, StopFunction } from "../../type"
+import { debug } from "../../function"
+import { Interaction } from "discord.js"
+
+export async function execute(commands: Map<string, Command>, interaction: Interaction, middleware: Array<Middleware>) {
+    if (!interaction.isCommand()) return
+
+    const command = commands.get(interaction.commandName)
+    if (!command) return
+
+    const { run } = command
+    if (!run || typeof run !== "function") {
+        return debug.warn(`Command ${interaction.commandName} does not have a run function`, { command })
+    }
+
+    if (middleware && middleware.length) {
+        let ShouldStop = false
+        let reason
+
+        const stop: StopFunction = (text?: string) => {
+            ShouldStop = true
+            if (text) {
+                reason = text
+            } else {
+                reason = "No reason provided"
+            }
+        }
+
+        let index = 0
+
+        for (; index < middleware.length; index++) {
+            const fn = middleware[index]
+            await fn(command, interaction, stop)
+            if (ShouldStop) break
+        }
+
+        if (ShouldStop) {
+            return debug.info(`A middleware stopped execution`, { index, reason })
+        }
+    }
+
+    try {
+        await run(interaction)
+    } catch (error) {
+        debug.error(`Error in command ${interaction.commandName} (${interaction.id})`, { error })
+        throw error
+    }
+}

package/src/handler/command/fetch-command.ts

@@ -0,0 +1,27 @@
+import { GetFilePaths, debug, GenerateList } from "../../function"
+import { Command } from "../../type"
+
+export function ftc_command(data: string) {
+    const files = GetFilePaths(data, true).filter((path) => path.endsWith(".js") || path.endsWith(".ts"))
+    const commands = new Map<string, Command>()
+
+    for (const file of files) {
+        const command: Command = require(file)
+        if (!("data" in command)) {
+            debug.warn(`Ignoring: Command ${file} does not export "data".`, { command })
+            continue
+        }
+
+        if (!("run" in command)) {
+            debug.warn(`Ignoring: Command ${file} does not export "run".`, { command })
+            continue
+        }
+
+        commands.set(command.data.name, command)
+    }
+
+    debug.debug(`${GenerateList("commands", files, data)}`)
+    debug.debug(`Found ${commands.size} commands`, { commands })
+
+    return commands
+}

package/src/handler/command/index.ts

@@ -0,0 +1,26 @@
+import { autocomplete } from "./autocomplete"
+import { ftc_command } from "./fetch-command"
+import { debug } from "../../function"
+import { register } from "./register"
+import { Options } from "../../type"
+import { execute } from "./execute"
+import { Client, InteractionType } from "discord.js"
+import { isMap } from "lodash"
+
+export function command_handler(
+    data: NonNullable<Options["command"]>,
+    client: Client,
+    middleware: Options["middleware"]
+) {
+    if (middleware) middleware = typeof middleware === "function" ? [middleware] : middleware
+    const commands = isMap(data) ? data : ftc_command(data)
+
+    client.on("ready", async (client) => await register(commands, client))
+    client.on("interactionCreate", async (interaction) => {
+        debug.info(`Command handler triggered`, { id: interaction.id, type: InteractionType[interaction.type] })
+        await execute(commands, interaction, middleware ?? ([] as any))
+        await autocomplete(commands, interaction)
+    })
+
+    debug.info("Command handler loaded")
+}

package/src/handler/command/register.ts

@@ -0,0 +1,15 @@
+import { Client } from "discord.js"
+import { Command } from "../../type"
+import { debug } from "../../function"
+
+export async function register(commands: Map<string, Command>, client: Client<true>) {
+    const cmd = Array.from(commands.values()).map((c) => c.data)
+
+    try {
+        await client.application.commands.set(cmd)
+        debug.info(`Successfully reloaded ${cmd.length} application (/) commands.`)
+    } catch (error: any) {
+        debug.error(`Error reloading application (/) commands`)
+        throw error
+    }
+}

package/src/handler/event/fetch-event.ts

@@ -0,0 +1,35 @@
+import { GetFolderPaths, GetFilePaths, debug, GenerateList } from "../../function"
+import { ClientEvents } from "discord.js"
+
+export function ftc_event(data: string) {
+    const EventFolderPaths = GetFolderPaths(data)
+    const FilePaths = []
+    const event = new Map<keyof ClientEvents, Array<(...arg: any) => any>>()
+
+    for (const EventFolderPath of EventFolderPaths) {
+        const eventName = EventFolderPath.replace(/\\/g, "/").split("/").pop() as string
+
+        const EventFilePaths = GetFilePaths(EventFolderPath, true).filter(
+            (path) => path.endsWith(".js") || path.endsWith(".ts")
+        )
+
+        const fun: Array<(...arg: any) => any> = []
+        for (const EventFilePath of EventFilePaths) {
+            const obj = require(EventFilePath)
+            const fn = typeof obj === "function" ? obj : obj.default
+
+            if (typeof fn !== "function") {
+                debug.warn(`Ignoring: Event ${EventFilePath} does not export a function.`, { obj })
+                continue
+            }
+
+            FilePaths.push(EventFilePath)
+            fun.push(fn)
+        }
+
+        event.set(eventName as any, fun)
+    }
+
+    debug.debug(`${GenerateList("events", FilePaths, data)}`)
+    return event
+}

package/src/handler/event/index.ts

@@ -0,0 +1,11 @@
+import { ftc_event } from "./fetch-event"
+import { debug } from "../../function"
+import { Options } from "../../type"
+import { OnEvent } from "./on-event"
+import { Client } from "discord.js"
+import { isMap } from "lodash"
+
+export function event_handler(data: NonNullable<Options["event"]>, client: Client) {
+    OnEvent(client, isMap(data) ? data : ftc_event(data))
+    debug.info("Event handler loaded")
+}

package/src/handler/event/on-event.ts

@@ -0,0 +1,25 @@
+import { debug, CTSError } from "../../function"
+import { Client, ClientEvents } from "discord.js"
+import { isMap } from "lodash"
+
+export function OnEvent(
+    client: Client,
+    map: Map<keyof ClientEvents, ((...arg: any) => any) | Array<(...arg: any) => any>>
+) {
+    if (!isMap(map)) {
+        debug.error("Event handler must be a Map", { received: map })
+        throw new CTSError("Event handler must be a Map")
+    }
+
+    for (const [name, fn] of map) {
+        const func = typeof fn === "function" ? [fn] : fn
+        for (const fn of func) {
+            if (typeof fn === "function") {
+                client.on(name, (...arg) => fn(...arg, client))
+            } else {
+                debug.error("Event handler must be a function", `name: ${name}`, `function: ${fn}`)
+                throw new CTSError("Event handler must be a function")
+            }
+        }
+    }
+}

package/src/handler/index.ts

@@ -0,0 +1,33 @@
+import { selectmenu_handler } from "./selectmenu"
+import { CTSError, debug } from "../function"
+import { command_handler } from "./command"
+import { button_handler } from "./button"
+import { event_handler } from "./event"
+import { modal_handler } from "./modal"
+import { Options } from "../type"
+import { version } from "discord.js"
+
+export let IsDebugEnabled = false
+
+export function handler({ debug: dbg, client, event, command, button, modal, selectmenu, middleware }: Options) {
+    const djs = Number(version.split(".").reduce((x, y, i) => (i === 2 ? x : `${x}.${y}`)))
+    IsDebugEnabled = typeof dbg === "boolean" ? dbg : false
+
+    if (djs < 14 || djs > 15) {
+        debug.warn("Your discord.js version might not be fully supported by command-ts handler")
+    }
+
+    if (!client) {
+        debug.error("Client is required", { received: client })
+        throw new CTSError("Client is required")
+    }
+
+    if (event) event_handler(event, client)
+    if (button) button_handler(button, client)
+    if (modal) modal_handler(modal, client)
+    if (selectmenu) selectmenu_handler(selectmenu, client)
+    if (command) command_handler(command, client, middleware)
+    debug.info("All Handler loaded")
+    // if (interaction_validator) interaction_validator_handler(interaction_validator, client)
+    // if (message_validator) message_validator_handler(message_validator, client)
+}

package/src/handler/modal/index.ts

@@ -0,0 +1,7 @@
+import { debug } from "../../function"
+import { Options } from "../../type"
+import { Client } from "discord.js"
+
+export function modal_handler(data: Options["modal"], client: Client) {
+    debug.warn("Modal handler is not implemented yet")
+}

package/src/handler/selectmenu/channel.ts

@@ -0,0 +1,7 @@
+import { Client } from "discord.js"
+import { SelectMenu } from "../../type"
+import { debug } from "../../function"
+
+export function channel_handler(data: SelectMenu["ChannelSelectMenu"], client: Client) {
+    debug.info("Channel select menu handler loaded")
+}

package/src/handler/selectmenu/index.ts

@@ -0,0 +1,7 @@
+import { debug } from "../../function"
+import { Options } from "../../type"
+import { Client } from "discord.js"
+
+export function selectmenu_handler(data: Options["selectmenu"], client: Client) {
+    debug.warn("Select menu handler is not implemented yet")
+}

package/src/handler/selectmenu/mentionable.ts

@@ -0,0 +1,7 @@
+import { Client } from "discord.js"
+import { SelectMenu } from "../../type"
+import { debug } from "../../function"
+
+export function mentionable_handler(data: SelectMenu["MentionableSelectMenu"], client: Client) {
+    debug.info("Mentionable select menu handler loaded")
+}

package/src/handler/selectmenu/role.ts

@@ -0,0 +1,7 @@
+import { Client } from "discord.js"
+import { SelectMenu } from "../../type"
+import { debug } from "../../function"
+
+export function role_handler(data: SelectMenu["RoleSelectMenu"], client: Client) {
+    debug.info("Role select menu handler loaded")
+}

package/src/handler/selectmenu/string.ts

@@ -0,0 +1,7 @@
+import { Client } from "discord.js"
+import { SelectMenu } from "../../type"
+import { debug } from "../../function"
+
+export function string_handler(data: SelectMenu["StringSelectMenu"], client: Client) {
+    debug.info("String select menu handler loaded")
+}