command-ts 0.0.1 → 0.0.2-dev.20260105052257

package/.turbo/turbo-build.log

@@ -0,0 +1,4 @@
+
+> command-ts@0.0.2 build /home/runner/work/command-ts/command-ts/packages/command-ts
+> (node --eval "require('node:fs').rmSync('out', { recursive: true, force: true })" || true) && tsc
+

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 softwarexplus
+Copyright (c) 2026 xcfio
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/out/function/CTSError.d.ts

@@ -0,0 +1,3 @@
+export declare class CTSError extends Error {
+    constructor(message: string);
+}

package/out/function/CTSError.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CTSError = void 0;
+class CTSError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CTSError";
+    }
+}
+exports.CTSError = CTSError;

package/out/function/debug.d.ts

@@ -0,0 +1,25 @@
+export declare const enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3
+}
+type LoggerConfig = {
+    minLevel: LogLevel;
+    includeTimestamp: boolean;
+    dateFormat: Intl.DateTimeFormatOptions;
+    timeFormat: Intl.DateTimeFormatOptions;
+};
+declare const createLogger: (customConfig?: Partial<LoggerConfig>) => {
+    debug: (message: unknown, ...args: unknown[]) => void;
+    info: (message: unknown, ...args: unknown[]) => void;
+    warn: (message: unknown, ...args: unknown[]) => void;
+    error: (message: unknown, ...args: unknown[]) => void;
+};
+export declare const debug: {
+    debug: (message: unknown, ...args: unknown[]) => void;
+    info: (message: unknown, ...args: unknown[]) => void;
+    warn: (message: unknown, ...args: unknown[]) => void;
+    error: (message: unknown, ...args: unknown[]) => void;
+};
+export { createLogger };

package/out/function/debug.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = exports.debug = void 0;
+const colorette_1 = require("colorette");
+const handler_1 = require("../handler");
+const node_util_1 = require("node:util");
+const defaultConfig = {
+    minLevel: 0 /* 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) => {
+    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, config) => {
+    const levelMap = {
+        DEBUG: 0 /* LogLevel.DEBUG */,
+        INFO: 1 /* LogLevel.INFO */,
+        WARN: 2 /* LogLevel.WARN */,
+        ERROR: 3 /* LogLevel.ERROR */
+    };
+    return levelMap[level] >= config.minLevel;
+};
+const formatArgs = (args) => {
+    if (args.length === 0)
+        return "";
+    let str = "";
+    for (const obj of args) {
+        str += (0, node_util_1.inspect)(obj, { colors: true, depth: Infinity });
+        str += " ";
+    }
+    return str;
+};
+const createLog = (config) => {
+    return (level, color, message, ...args) => {
+        if (shouldLog(level, config)) {
+            const timestamp = getTimestamp(config);
+            const levelStr = color(`[${level}]`);
+            const formattedArgs = formatArgs(args);
+            if (handler_1.IsDebugEnabled)
+                console.log(`${(0, colorette_1.blue)(timestamp)} ${levelStr} ${message} ${formattedArgs}`);
+            if (level === "WARN")
+                process.emitWarning(`${message}`);
+        }
+    };
+};
+const createLogger = (customConfig = {}) => {
+    const config = { ...defaultConfig, ...customConfig };
+    const log = createLog(config);
+    return {
+        debug: (message, ...args) => log("DEBUG", colorette_1.gray, message, ...args),
+        info: (message, ...args) => log("INFO", colorette_1.green, message, ...args),
+        warn: (message, ...args) => log("WARN", colorette_1.yellow, message, ...args),
+        error: (message, ...args) => log("ERROR", colorette_1.red, message, ...args)
+    };
+};
+exports.createLogger = createLogger;
+exports.debug = createLogger();

package/out/function/index.d.ts

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

package/out/function/index.js

@@ -0,0 +1,20 @@
+"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 });
+__exportStar(require("./CTSError"), exports);
+__exportStar(require("./debug"), exports);
+__exportStar(require("./read-dir"), exports);
+__exportStar(require("./visual"), exports);

package/out/function/read-dir.d.ts

@@ -0,0 +1,2 @@
+export declare function GetFilePaths(directory: string, nesting?: boolean): string[];
+export declare function GetFolderPaths(directory: string, nesting?: boolean): string[];

package/out/function/read-dir.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetFilePaths = GetFilePaths;
+exports.GetFolderPaths = GetFolderPaths;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+function GetFilePaths(directory, nesting) {
+    let file_paths = [];
+    if (!directory)
+        return file_paths;
+    const files = (0, node_fs_1.readdirSync)(directory, { withFileTypes: true });
+    for (const file of files) {
+        const file_path = (0, node_path_1.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;
+}
+function GetFolderPaths(directory, nesting) {
+    let folder_paths = [];
+    if (!directory)
+        return folder_paths;
+    const folders = (0, node_fs_1.readdirSync)(directory, { withFileTypes: true });
+    for (const folder of folders) {
+        const folder_path = (0, node_path_1.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/out/function/visual.d.ts

@@ -0,0 +1 @@
+export declare function GenerateList(type: string, filePaths: string[], srcDir: string): string;

package/out/function/visual.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateList = GenerateList;
+const colorette_1 = require("colorette");
+const path_1 = __importDefault(require("path"));
+function GenerateList(type, filePaths, srcDir) {
+    const x = [];
+    const commandCount = filePaths.length;
+    // Create directory structure from file paths
+    const directoryStructure = {};
+    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_1.default.sep);
+        // File name without extension
+        const fileName = path_1.default.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, level = 0) {
+        // Process directories first
+        for (const dir in structure) {
+            if (dir === "__files")
+                continue;
+            const indent = "  ".repeat(level);
+            x.push(`${indent}├─ ${(0, colorette_1.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}├─ ${(0, colorette_1.cyan)(file)}`);
+            }
+        }
+    }
+    // Generate command list
+    processStructure(directoryStructure);
+    // Add summary at the beginning
+    x.unshift(`Loaded ${(0, colorette_1.magenta)(commandCount.toString())} ${type}:`);
+    return x.join("\n");
+}

package/out/handler/button/index.d.ts

@@ -0,0 +1,3 @@
+import { Options } from "../../type";
+import { Client } from "discord.js";
+export declare function button_handler(data: Options["button"], client: Client): void;

package/out/handler/button/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.button_handler = button_handler;
+const function_1 = require("../../function");
+function button_handler(data, client) {
+    function_1.debug.warn("Button handler is not implemented yet");
+}

package/out/handler/command/autocomplete.d.ts

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

package/out/handler/command/autocomplete.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autocomplete = autocomplete;
+async function autocomplete(commands, interaction) { }

package/out/handler/command/execute.d.ts

@@ -0,0 +1,3 @@
+import { Command, Middleware } from "../../type";
+import { Interaction } from "discord.js";
+export declare function execute(commands: Map<string, Command>, interaction: Interaction, middleware: Array<Middleware>): Promise<void>;

package/out/handler/command/execute.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const function_1 = require("../../function");
+async function execute(commands, interaction, middleware) {
+    if (!interaction.isCommand())
+        return;
+    const command = commands.get(interaction.commandName);
+    if (!command)
+        return;
+    const { run } = command;
+    if (!run || typeof run !== "function") {
+        return function_1.debug.warn(`Command ${interaction.commandName} does not have a run function`, { command });
+    }
+    if (middleware && middleware.length) {
+        let ShouldStop = false;
+        let reason;
+        const stop = (text) => {
+            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 function_1.debug.info(`A middleware stopped execution`, { index, reason });
+        }
+    }
+    try {
+        await run(interaction);
+    }
+    catch (error) {
+        function_1.debug.error(`Error in command ${interaction.commandName} (${interaction.id})`, { error });
+        throw error;
+    }
+}

package/out/handler/command/fetch-command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "../../type";
+export declare function ftc_command(data: string): Map<string, Command>;

package/out/handler/command/fetch-command.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ftc_command = ftc_command;
+const function_1 = require("../../function");
+function ftc_command(data) {
+    const files = (0, function_1.GetFilePaths)(data, true).filter((path) => path.endsWith(".js") || path.endsWith(".ts"));
+    const commands = new Map();
+    for (const file of files) {
+        const command = require(file);
+        if (!("data" in command)) {
+            function_1.debug.warn(`Ignoring: Command ${file} does not export "data".`, { command });
+            continue;
+        }
+        if (!("run" in command)) {
+            function_1.debug.warn(`Ignoring: Command ${file} does not export "run".`, { command });
+            continue;
+        }
+        commands.set(command.data.name, command);
+    }
+    function_1.debug.debug(`${(0, function_1.GenerateList)("commands", files, data)}`);
+    function_1.debug.debug(`Found ${commands.size} commands`, { commands });
+    return commands;
+}

package/out/handler/command/index.d.ts

@@ -0,0 +1,3 @@
+import { Options } from "../../type";
+import { Client } from "discord.js";
+export declare function command_handler(data: NonNullable<Options["command"]>, client: Client, middleware: Options["middleware"]): void;

package/out/handler/command/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command_handler = command_handler;
+const autocomplete_1 = require("./autocomplete");
+const fetch_command_1 = require("./fetch-command");
+const function_1 = require("../../function");
+const register_1 = require("./register");
+const execute_1 = require("./execute");
+const discord_js_1 = require("discord.js");
+const lodash_1 = require("lodash");
+function command_handler(data, client, middleware) {
+    if (middleware)
+        middleware = typeof middleware === "function" ? [middleware] : middleware;
+    const commands = (0, lodash_1.isMap)(data) ? data : (0, fetch_command_1.ftc_command)(data);
+    client.on("ready", async (client) => await (0, register_1.register)(commands, client));
+    client.on("interactionCreate", async (interaction) => {
+        function_1.debug.info(`Command handler triggered`, { id: interaction.id, type: discord_js_1.InteractionType[interaction.type] });
+        await (0, execute_1.execute)(commands, interaction, middleware ?? []);
+        await (0, autocomplete_1.autocomplete)(commands, interaction);
+    });
+    function_1.debug.info("Command handler loaded");
+}

package/out/handler/command/register.d.ts

@@ -0,0 +1,3 @@
+import { Client } from "discord.js";
+import { Command } from "../../type";
+export declare function register(commands: Map<string, Command>, client: Client<true>): Promise<void>;

package/out/handler/command/register.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = register;
+const function_1 = require("../../function");
+async function register(commands, client) {
+    const cmd = Array.from(commands.values()).map((c) => c.data);
+    try {
+        await client.application.commands.set(cmd);
+        function_1.debug.info(`Successfully reloaded ${cmd.length} application (/) commands.`);
+    }
+    catch (error) {
+        function_1.debug.error(`Error reloading application (/) commands`);
+        throw error;
+    }
+}

package/out/handler/event/fetch-event.d.ts

@@ -0,0 +1,2 @@
+import { ClientEvents } from "discord.js";
+export declare function ftc_event(data: string): Map<keyof ClientEvents, ((...arg: any) => any)[]>;

package/out/handler/event/fetch-event.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ftc_event = ftc_event;
+const function_1 = require("../../function");
+function ftc_event(data) {
+    const EventFolderPaths = (0, function_1.GetFolderPaths)(data);
+    const FilePaths = [];
+    const event = new Map();
+    for (const EventFolderPath of EventFolderPaths) {
+        const eventName = EventFolderPath.replace(/\\/g, "/").split("/").pop();
+        const EventFilePaths = (0, function_1.GetFilePaths)(EventFolderPath, true).filter((path) => path.endsWith(".js") || path.endsWith(".ts"));
+        const fun = [];
+        for (const EventFilePath of EventFilePaths) {
+            const obj = require(EventFilePath);
+            const fn = typeof obj === "function" ? obj : obj.default;
+            if (typeof fn !== "function") {
+                function_1.debug.warn(`Ignoring: Event ${EventFilePath} does not export a function.`, { obj });
+                continue;
+            }
+            FilePaths.push(EventFilePath);
+            fun.push(fn);
+        }
+        event.set(eventName, fun);
+    }
+    function_1.debug.debug(`${(0, function_1.GenerateList)("events", FilePaths, data)}`);
+    return event;
+}

package/out/handler/event/index.d.ts

@@ -0,0 +1,3 @@
+import { Options } from "../../type";
+import { Client } from "discord.js";
+export declare function event_handler(data: NonNullable<Options["event"]>, client: Client): void;

package/out/handler/event/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.event_handler = event_handler;
+const fetch_event_1 = require("./fetch-event");
+const function_1 = require("../../function");
+const on_event_1 = require("./on-event");
+const lodash_1 = require("lodash");
+function event_handler(data, client) {
+    (0, on_event_1.OnEvent)(client, (0, lodash_1.isMap)(data) ? data : (0, fetch_event_1.ftc_event)(data));
+    function_1.debug.info("Event handler loaded");
+}

package/out/handler/event/on-event.d.ts

@@ -0,0 +1,2 @@
+import { Client, ClientEvents } from "discord.js";
+export declare function OnEvent(client: Client, map: Map<keyof ClientEvents, ((...arg: any) => any) | Array<(...arg: any) => any>>): void;

package/out/handler/event/on-event.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnEvent = OnEvent;
+const function_1 = require("../../function");
+const lodash_1 = require("lodash");
+function OnEvent(client, map) {
+    if (!(0, lodash_1.isMap)(map)) {
+        function_1.debug.error("Event handler must be a Map", { received: map });
+        throw new function_1.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 {
+                function_1.debug.error("Event handler must be a function", `name: ${name}`, `function: ${fn}`);
+                throw new function_1.CTSError("Event handler must be a function");
+            }
+        }
+    }
+}

package/out/handler/index.d.ts

@@ -0,0 +1,3 @@
+import { Options } from "../type";
+export declare let IsDebugEnabled: boolean;
+export declare function handler({ debug: dbg, client, event, command, button, modal, selectmenu, middleware }: Options): void;

package/out/handler/index.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsDebugEnabled = void 0;
+exports.handler = handler;
+const selectmenu_1 = require("./selectmenu");
+const function_1 = require("../function");
+const command_1 = require("./command");
+const button_1 = require("./button");
+const event_1 = require("./event");
+const modal_1 = require("./modal");
+const discord_js_1 = require("discord.js");
+exports.IsDebugEnabled = false;
+function handler({ debug: dbg, client, event, command, button, modal, selectmenu, middleware }) {
+    const djs = Number(discord_js_1.version.split(".").reduce((x, y, i) => (i === 2 ? x : `${x}.${y}`)));
+    exports.IsDebugEnabled = typeof dbg === "boolean" ? dbg : false;
+    if (djs < 14 || djs > 15) {
+        function_1.debug.warn("Your discord.js version might not be fully supported by command-ts handler");
+    }
+    if (!client) {
+        function_1.debug.error("Client is required", { received: client });
+        throw new function_1.CTSError("Client is required");
+    }
+    if (event)
+        (0, event_1.event_handler)(event, client);
+    if (button)
+        (0, button_1.button_handler)(button, client);
+    if (modal)
+        (0, modal_1.modal_handler)(modal, client);
+    if (selectmenu)
+        (0, selectmenu_1.selectmenu_handler)(selectmenu, client);
+    if (command)
+        (0, command_1.command_handler)(command, client, middleware);
+    function_1.debug.info("All Handler loaded");
+    // if (interaction_validator) interaction_validator_handler(interaction_validator, client)
+    // if (message_validator) message_validator_handler(message_validator, client)
+}

package/out/handler/modal/index.d.ts

@@ -0,0 +1,3 @@
+import { Options } from "../../type";
+import { Client } from "discord.js";
+export declare function modal_handler(data: Options["modal"], client: Client): void;

package/out/handler/modal/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modal_handler = modal_handler;
+const function_1 = require("../../function");
+function modal_handler(data, client) {
+    function_1.debug.warn("Modal handler is not implemented yet");
+}

package/out/handler/selectmenu/channel.d.ts

@@ -0,0 +1,3 @@
+import { Client } from "discord.js";
+import { SelectMenu } from "../../type";
+export declare function channel_handler(data: SelectMenu["ChannelSelectMenu"], client: Client): void;

package/out/handler/selectmenu/channel.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.channel_handler = channel_handler;
+const function_1 = require("../../function");
+function channel_handler(data, client) {
+    function_1.debug.info("Channel select menu handler loaded");
+}

package/out/handler/selectmenu/index.d.ts

@@ -0,0 +1,3 @@
+import { Options } from "../../type";
+import { Client } from "discord.js";
+export declare function selectmenu_handler(data: Options["selectmenu"], client: Client): void;

package/out/handler/selectmenu/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectmenu_handler = selectmenu_handler;
+const function_1 = require("../../function");
+function selectmenu_handler(data, client) {
+    function_1.debug.warn("Select menu handler is not implemented yet");
+}

package/out/handler/selectmenu/mentionable.d.ts

@@ -0,0 +1,3 @@
+import { Client } from "discord.js";
+import { SelectMenu } from "../../type";
+export declare function mentionable_handler(data: SelectMenu["MentionableSelectMenu"], client: Client): void;

package/out/handler/selectmenu/mentionable.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mentionable_handler = mentionable_handler;
+const function_1 = require("../../function");
+function mentionable_handler(data, client) {
+    function_1.debug.info("Mentionable select menu handler loaded");
+}

package/out/handler/selectmenu/role.d.ts

@@ -0,0 +1,3 @@
+import { Client } from "discord.js";
+import { SelectMenu } from "../../type";
+export declare function role_handler(data: SelectMenu["RoleSelectMenu"], client: Client): void;

package/out/handler/selectmenu/role.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.role_handler = role_handler;
+const function_1 = require("../../function");
+function role_handler(data, client) {
+    function_1.debug.info("Role select menu handler loaded");
+}

package/out/handler/selectmenu/string.d.ts

@@ -0,0 +1,3 @@
+import { Client } from "discord.js";
+import { SelectMenu } from "../../type";
+export declare function string_handler(data: SelectMenu["StringSelectMenu"], client: Client): void;

package/out/handler/selectmenu/string.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.string_handler = string_handler;
+const function_1 = require("../../function");
+function string_handler(data, client) {
+    function_1.debug.info("String select menu handler loaded");
+}

package/out/handler/selectmenu/user.d.ts

@@ -0,0 +1,3 @@
+import { Client } from "discord.js";
+import { SelectMenu } from "../../type";
+export declare function user_handler(data: SelectMenu["UserSelectMenu"], client: Client): void;

package/out/handler/selectmenu/user.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.user_handler = user_handler;
+const function_1 = require("../../function");
+function user_handler(data, client) {
+    function_1.debug.info("User select menu handler loaded");
+}