@pikokr/command.ts 3.0.0-dev.a94f324 → 3.0.0-dev.ca01eb5

package/dist/command/cooldown/type.d.ts

@@ -0,0 +1,8 @@
+export declare enum CoolDownType {
+    USER = 0,
+    CHANNEL = 1,
+    GUILD = 2,
+    ROLE = 3,
+    CATEGORY = 4,
+    MEMBER = 5
+}

package/dist/command/cooldown/type.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoolDownType = void 0;
+var CoolDownType;
+(function (CoolDownType) {
+    CoolDownType[CoolDownType["USER"] = 0] = "USER";
+    CoolDownType[CoolDownType["CHANNEL"] = 1] = "CHANNEL";
+    CoolDownType[CoolDownType["GUILD"] = 2] = "GUILD";
+    CoolDownType[CoolDownType["ROLE"] = 3] = "ROLE";
+    CoolDownType[CoolDownType["CATEGORY"] = 4] = "CATEGORY";
+    CoolDownType[CoolDownType["MEMBER"] = 5] = "MEMBER";
+})(CoolDownType = exports.CoolDownType || (exports.CoolDownType = {}));

package/dist/command/decorator.d.ts

@@ -1,8 +1,16 @@
+import { Message, PermissionResolvable } from 'discord.js';
 declare type CommandOptions = {
     name: string;
-    aliases: string[];
+    aliases: string[] | ((msg: Message) => string[]);
 };
 export declare const command: (options?: Partial<CommandOptions>) => (target: Object, propertyKey: string) => void;
 export declare const argumentConverter: (type: object, requireParameter?: boolean) => (target: Object, propertyKey: string) => void;
+export declare const slashArgumentConverter: (type: object) => (target: Object, propertyKey: string) => void;
 export declare const optional: ParameterDecorator;
+export declare const rest: ParameterDecorator;
+export declare const ownerOnly: MethodDecorator;
+export declare const guildOnly: MethodDecorator;
+export declare const dmOnly: MethodDecorator;
+export declare const requireUserPermissions: (permission: PermissionResolvable) => MethodDecorator;
+export declare const requireClientPermissions: (permission: PermissionResolvable) => MethodDecorator;
 export {};

package/dist/command/decorator.js

@@ -1,20 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.optional = exports.argumentConverter = exports.command = void 0;
+exports.requireClientPermissions = exports.requireUserPermissions = exports.dmOnly = exports.guildOnly = exports.ownerOnly = exports.rest = exports.optional = exports.slashArgumentConverter = exports.argumentConverter = exports.command = void 0;
 const constants_1 = require("../constants");
 const Command_1 = require("./Command");
 const utils_1 = require("../utils");
 const ArgumentConverter_1 = require("./ArgumentConverter");
+const utils_2 = require("./utils");
+const discord_js_1 = require("discord.js");
+const error_1 = require("../error");
 const command = (options = {}) => {
     return (target, propertyKey) => {
         utils_1.checkTarget(target);
         let properties = Reflect.getMetadata(constants_1.KCommands, target);
         const params = Reflect.getMetadata('design:paramtypes', target, propertyKey);
-        const optionals = Reflect.getMetadata(constants_1.KOptionals, target, propertyKey) || [];
+        const optionals = Reflect.getMetadata(constants_1.KOptionals, target, propertyKey) || -1;
+        const rest = Reflect.getMetadata(constants_1.KRest, target, propertyKey) || -1;
         const command = new Command_1.Command(Reflect.get(target, propertyKey), params.map((x, i) => ({
             type: x,
-            optional: optionals.includes(i),
-        })), options.name || propertyKey, options.aliases || []);
+            optional: optionals === -1 ? false : optionals <= i,
+            rest: rest === -1 ? false : rest === i,
+        })), options.name || propertyKey, options.aliases || [], target, propertyKey);
         if (properties) {
             properties.push(command);
         }
@@ -40,15 +45,68 @@ const argumentConverter = (type, requireParameter = true) => {
     };
 };
 exports.argumentConverter = argumentConverter;
+const slashArgumentConverter = (type) => {
+    return (target, propertyKey) => {
+        utils_1.checkTarget(target);
+        let properties = Reflect.getMetadata(constants_1.KSlashArgumentConverters, target);
+        const converter = new ArgumentConverter_1.SlashArgumentConverter(type, Reflect.get(target, propertyKey));
+        if (properties) {
+            properties.push(converter);
+        }
+        else {
+            properties = [converter];
+            Reflect.defineMetadata(constants_1.KSlashArgumentConverters, properties, target);
+        }
+    };
+};
+exports.slashArgumentConverter = slashArgumentConverter;
 const optional = (target, propertyKey, parameterIndex) => {
     utils_1.checkTarget(target);
-    let properties = Reflect.getMetadata(constants_1.KOptionals, target, propertyKey);
-    if (properties) {
-        properties.push(parameterIndex);
-    }
-    else {
-        properties = [parameterIndex];
-        Reflect.defineMetadata(constants_1.KOptionals, properties, target, propertyKey);
-    }
+    Reflect.defineMetadata(constants_1.KOptionals, parameterIndex, target, propertyKey);
 };
 exports.optional = optional;
+const rest = (target, propertyKey, parameterIndex) => {
+    utils_1.checkTarget(target);
+    const params = Reflect.getMetadata('design:paramtypes', target, propertyKey);
+    if (params.length - 1 !== parameterIndex)
+        throw new Error('Rest decorator must be used at last argument.');
+    if (params[parameterIndex] !== String)
+        throw new Error('Rest argument type must be "String"');
+    Reflect.defineMetadata(constants_1.KRest, parameterIndex, target, propertyKey);
+};
+exports.rest = rest;
+exports.ownerOnly = utils_2.createCheckDecorator((msg) => msg.data.cts.owners.includes(msg.author.id), (i) => i.data.cts.owners.includes(i.user.id));
+exports.guildOnly = utils_2.createCheckDecorator((msg) => !!msg.guild, (i) => !!i.guildId);
+exports.dmOnly = utils_2.createCheckDecorator((msg) => !msg.guild, (i) => !i.guildId);
+const requireUserPermissions = (permission) => utils_2.createCheckDecorator((msg) => {
+    if (!msg.guild || !msg.member)
+        throw new Error('This command must be used in guild.');
+    if (msg.member.permissionsIn(msg.channel).has(permission)) {
+        return true;
+    }
+    throw new error_1.UserPermissionRequired(msg.member, new discord_js_1.Permissions(permission));
+}, (i) => {
+    if (!i.guild || !i.member)
+        throw new Error('This command must be used in serer.');
+    if (!(i.member instanceof discord_js_1.GuildMember) || i.member.permissionsIn(i.channel).has(permission)) {
+        return true;
+    }
+    throw new error_1.UserPermissionRequired(i.member, new discord_js_1.Permissions(permission));
+});
+exports.requireUserPermissions = requireUserPermissions;
+const requireClientPermissions = (permission) => utils_2.createCheckDecorator((msg) => {
+    if (!msg.guild)
+        throw new Error('This command must be used in guild.');
+    if (msg.guild.me.permissionsIn(msg.channel).has(permission)) {
+        return true;
+    }
+    throw new error_1.ClientPermissionRequired(new discord_js_1.Permissions(permission));
+}, (i) => {
+    if (!i.guild)
+        throw new Error('This command must be used in guild.');
+    if (i.guild.me.permissionsIn(i.channel).has(permission)) {
+        return true;
+    }
+    throw new error_1.ClientPermissionRequired(new discord_js_1.Permissions(permission));
+});
+exports.requireClientPermissions = requireClientPermissions;

package/dist/command/index.d.ts

@@ -1,3 +1,5 @@
 export * from './Command';
 export * from './decorator';
 export * from './ArgumentConverter';
+export * from './utils';
+export * from './cooldown';

package/dist/command/index.js

@@ -13,3 +13,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Command"), exports);
 __exportStar(require("./decorator"), exports);
 __exportStar(require("./ArgumentConverter"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./cooldown"), exports);

package/dist/command/utils.d.ts

@@ -0,0 +1,2 @@
+import { CommandInteraction, Message } from 'discord.js';
+export declare const createCheckDecorator: (execute: ((msg: Message) => boolean | Promise<boolean>) | null, slashExecute?: ((i: CommandInteraction) => boolean | Promise<boolean>) | undefined) => MethodDecorator;

package/dist/command/utils.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCheckDecorator = void 0;
+const constants_1 = require("../constants");
+const createCheckDecorator = (execute, slashExecute) => {
+    return (target, propertyKey) => {
+        if (execute) {
+            let properties = Reflect.getMetadata(constants_1.KCommandChecks, target, propertyKey);
+            if (properties) {
+                properties.push(execute);
+            }
+            else {
+                properties = [execute];
+                Reflect.defineMetadata(constants_1.KCommandChecks, properties, target, propertyKey);
+            }
+        }
+        if (slashExecute) {
+            let properties = Reflect.getMetadata(constants_1.KSlashCommandChecks, target, propertyKey);
+            if (properties) {
+                properties.push(slashExecute);
+            }
+            else {
+                properties = [slashExecute];
+                Reflect.defineMetadata(constants_1.KSlashCommandChecks, properties, target, propertyKey);
+            }
+        }
+    };
+};
+exports.createCheckDecorator = createCheckDecorator;

package/dist/constants.d.ts

@@ -1,7 +1,13 @@
 export declare const KCommands: unique symbol;
+export declare const KSlashCommands: unique symbol;
+export declare const KSlashCommandOptions: unique symbol;
 export declare const KListeners: unique symbol;
 export declare const KModulePath: unique symbol;
 export declare const KListenerExecuteCache: unique symbol;
 export declare const KBuiltInModule: unique symbol;
 export declare const KOptionals: unique symbol;
+export declare const KRest: unique symbol;
 export declare const KArgumentConverters: unique symbol;
+export declare const KSlashArgumentConverters: unique symbol;
+export declare const KCommandChecks: unique symbol;
+export declare const KSlashCommandChecks: unique symbol;

package/dist/constants.js

@@ -1,10 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KArgumentConverters = exports.KOptionals = exports.KBuiltInModule = exports.KListenerExecuteCache = exports.KModulePath = exports.KListeners = exports.KCommands = void 0;
+exports.KSlashCommandChecks = exports.KCommandChecks = exports.KSlashArgumentConverters = exports.KArgumentConverters = exports.KRest = exports.KOptionals = exports.KBuiltInModule = exports.KListenerExecuteCache = exports.KModulePath = exports.KListeners = exports.KSlashCommandOptions = exports.KSlashCommands = exports.KCommands = void 0;
 exports.KCommands = Symbol('Command.TS Commands');
+exports.KSlashCommands = Symbol('Command.TS Slash Commands');
+exports.KSlashCommandOptions = Symbol('Command.TS Slash Command Options');
 exports.KListeners = Symbol('Command.TS Listeners');
 exports.KModulePath = Symbol('Command.TS Module Path');
 exports.KListenerExecuteCache = Symbol('Command.TS Module Identifier');
 exports.KBuiltInModule = Symbol('Command.TS Built-In Module');
 exports.KOptionals = Symbol('Command.TS Optional Parameters');
+exports.KRest = Symbol('Command.TS Rest Parameter');
 exports.KArgumentConverters = Symbol('Command.TS Argument Converter');
+exports.KSlashArgumentConverters = Symbol('Command.TS Slash Argument Converter');
+exports.KCommandChecks = Symbol('Command.TS Command Checks');
+exports.KSlashCommandChecks = Symbol('Command.TS Slash Command Checks');

package/dist/error/ArgumentConverterNotFound.d.ts

@@ -1,7 +1,13 @@
-import { Message } from 'discord.js';
+import { CommandInteraction, Message } from 'discord.js';
 import type { Argument } from '../command';
+import type { SlashArgument } from '../slashCommand';
 export declare class ArgumentConverterNotFound extends Error {
     type: Argument;
     msg: Message;
     constructor(type: Argument, msg: Message);
 }
+export declare class SlashArgumentConverterNotFound extends Error {
+    type: SlashArgument;
+    interaction: CommandInteraction;
+    constructor(type: SlashArgument, interaction: CommandInteraction);
+}

package/dist/error/ArgumentConverterNotFound.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArgumentConverterNotFound = void 0;
+exports.SlashArgumentConverterNotFound = exports.ArgumentConverterNotFound = void 0;
 class ArgumentConverterNotFound extends Error {
     constructor(type, msg) {
         super(`Argument converter ${type.type.name} not found.`);
@@ -9,3 +9,11 @@ class ArgumentConverterNotFound extends Error {
     }
 }
 exports.ArgumentConverterNotFound = ArgumentConverterNotFound;
+class SlashArgumentConverterNotFound extends Error {
+    constructor(type, interaction) {
+        super(`Argument converter ${type.type.name} not found.`);
+        this.type = type;
+        this.interaction = interaction;
+    }
+}
+exports.SlashArgumentConverterNotFound = SlashArgumentConverterNotFound;

package/dist/error/ArgumentNotProvided.d.ts

@@ -1,6 +1,8 @@
 import { Message } from 'discord.js';
+import { Command } from '../command';
 export declare class ArgumentNotProvided extends Error {
     index: number;
+    command: Command;
     msg: Message;
-    constructor(index: number, msg: Message);
+    constructor(index: number, command: Command, msg: Message);
 }

package/dist/error/ArgumentNotProvided.js

@@ -2,9 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArgumentNotProvided = void 0;
 class ArgumentNotProvided extends Error {
-    constructor(index, msg) {
+    constructor(index, command, msg) {
         super(`Required argument #${index} not provided.`);
         this.index = index;
+        this.command = command;
         this.msg = msg;
     }
 }

package/dist/error/CommandCheckFailed.d.ts

@@ -0,0 +1,13 @@
+import { CommandInteraction, Message } from 'discord.js';
+import { Command } from '../command';
+import { SlashCommand } from '../slashCommand';
+export declare class CommandCheckFailed extends Error {
+    msg: Message;
+    command: Command;
+    constructor(msg: Message, command: Command);
+}
+export declare class SlashCommandCheckFailed extends Error {
+    msg: CommandInteraction;
+    command: SlashCommand;
+    constructor(msg: CommandInteraction, command: SlashCommand);
+}

package/dist/error/CommandCheckFailed.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlashCommandCheckFailed = exports.CommandCheckFailed = void 0;
+class CommandCheckFailed extends Error {
+    constructor(msg, command) {
+        super();
+        this.msg = msg;
+        this.command = command;
+    }
+}
+exports.CommandCheckFailed = CommandCheckFailed;
+class SlashCommandCheckFailed extends Error {
+    constructor(msg, command) {
+        super();
+        this.msg = msg;
+        this.command = command;
+    }
+}
+exports.SlashCommandCheckFailed = SlashCommandCheckFailed;

package/dist/error/PermissionRequired.d.ts

@@ -0,0 +1,10 @@
+import { GuildMember, Permissions } from 'discord.js';
+export declare class UserPermissionRequired extends Error {
+    user: GuildMember;
+    permissions: Permissions;
+    constructor(user: GuildMember, permissions: Permissions);
+}
+export declare class ClientPermissionRequired extends Error {
+    permissions: Permissions;
+    constructor(permissions: Permissions);
+}

package/dist/error/PermissionRequired.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientPermissionRequired = exports.UserPermissionRequired = void 0;
+class UserPermissionRequired extends Error {
+    constructor(user, permissions) {
+        super();
+        this.user = user;
+        this.permissions = permissions;
+    }
+}
+exports.UserPermissionRequired = UserPermissionRequired;
+class ClientPermissionRequired extends Error {
+    constructor(permissions) {
+        super();
+        this.permissions = permissions;
+    }
+}
+exports.ClientPermissionRequired = ClientPermissionRequired;

package/dist/error/index.d.ts

@@ -2,3 +2,5 @@ export * from './InvalidTargetError';
 export * from './ModuleError';
 export * from './ArgumentNotProvided';
 export * from './ArgumentConverterNotFound';
+export * from './CommandCheckFailed';
+export * from './PermissionRequired';

package/dist/error/index.js

@@ -14,3 +14,5 @@ __exportStar(require("./InvalidTargetError"), exports);
 __exportStar(require("./ModuleError"), exports);
 __exportStar(require("./ArgumentNotProvided"), exports);
 __exportStar(require("./ArgumentConverterNotFound"), exports);
+__exportStar(require("./CommandCheckFailed"), exports);
+__exportStar(require("./PermissionRequired"), exports);

package/dist/index.d.ts

@@ -1,6 +1,9 @@
 import 'reflect-metadata';
+import './typings';
 export * from './interface';
 export * from './structures';
 export * from './error';
 export * from './command';
 export * from './listener';
+export * from './builtinModules/BuiltInModule';
+export * from './slashCommand';

package/dist/index.js

@@ -11,8 +11,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
+require("./typings");
 __exportStar(require("./interface"), exports);
 __exportStar(require("./structures"), exports);
 __exportStar(require("./error"), exports);
 __exportStar(require("./command"), exports);
 __exportStar(require("./listener"), exports);
+__exportStar(require("./builtinModules/BuiltInModule"), exports);
+__exportStar(require("./slashCommand"), exports);

package/dist/slashCommand/SlashCommand.d.ts

@@ -0,0 +1,19 @@
+import { SlashCommandBuilder } from '@discordjs/builders';
+import { Module } from '../structures';
+import { Snowflake } from 'discord.js';
+import { SlashCheckFunction } from '../command';
+export declare type SlashArgument = {
+    type: any;
+    name?: string;
+};
+export declare class SlashCommand {
+    commandBuilder: SlashCommandBuilder | Omit<SlashCommandBuilder, 'addSubcommand' | 'addSubcommandGroup'>;
+    private run;
+    module: Module;
+    params: SlashArgument[];
+    guild: Snowflake | Snowflake[] | undefined;
+    private key;
+    get checks(): SlashCheckFunction[];
+    execute(module: Module, args: any[]): any;
+    constructor(commandBuilder: SlashCommandBuilder | Omit<SlashCommandBuilder, 'addSubcommand' | 'addSubcommandGroup'>, run: Function, module: Module, params: SlashArgument[], guild: Snowflake | Snowflake[] | undefined, key: string | symbol);
+}

package/dist/slashCommand/SlashCommand.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlashCommand = void 0;
+const constants_1 = require("../constants");
+class SlashCommand {
+    constructor(commandBuilder, run, module, params, guild, key) {
+        this.commandBuilder = commandBuilder;
+        this.run = run;
+        this.module = module;
+        this.params = params;
+        this.guild = guild;
+        this.key = key;
+    }
+    get checks() {
+        return Reflect.getMetadata(constants_1.KSlashCommandChecks, this.module, this.key) || [];
+    }
+    execute(module, args) {
+        return this.run.apply(module, args);
+    }
+}
+exports.SlashCommand = SlashCommand;

package/dist/slashCommand/decorator.d.ts

@@ -0,0 +1,10 @@
+import { Snowflake } from 'discord.js';
+import { SlashCommandBuilder } from '@discordjs/builders';
+declare type SlashOptions = {
+    guild: Snowflake | Snowflake[];
+};
+export declare const slashCommand: (opt: Partial<SlashOptions> & {
+    command: SlashCommandBuilder | Omit<SlashCommandBuilder, 'addSubcommand' | 'addSubcommandGroup'>;
+}) => (target: Object, propertyKey: string) => void;
+export declare const option: (key: string) => ParameterDecorator;
+export {};

package/dist/slashCommand/decorator.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.option = exports.slashCommand = void 0;
+const discord_js_1 = require("discord.js");
+const utils_1 = require("../utils");
+const constants_1 = require("../constants");
+const SlashCommand_1 = require("./SlashCommand");
+const slashCommand = (opt) => {
+    return (target, propertyKey) => {
+        utils_1.checkTarget(target);
+        let properties = Reflect.getMetadata(constants_1.KSlashCommands, target);
+        const params = Reflect.getMetadata('design:paramtypes', target, propertyKey);
+        const options = Reflect.getMetadata(constants_1.KSlashCommandOptions, target, propertyKey) || new discord_js_1.Collection();
+        const command = new SlashCommand_1.SlashCommand(opt.command, Reflect.get(target, propertyKey), target, params.map((x, i) => ({
+            type: x,
+            name: options.get(i),
+        })), opt.guild, propertyKey);
+        if (properties) {
+            properties.push(command);
+        }
+        else {
+            properties = [command];
+            Reflect.defineMetadata(constants_1.KSlashCommands, properties, target);
+        }
+    };
+};
+exports.slashCommand = slashCommand;
+const option = (key) => (target, propertyKey, parameterIndex) => {
+    utils_1.checkTarget(target);
+    let properties = Reflect.getMetadata(constants_1.KSlashCommandOptions, target, propertyKey);
+    if (!properties) {
+        properties = new discord_js_1.Collection();
+        Reflect.defineMetadata(constants_1.KSlashCommandOptions, properties, target, propertyKey);
+    }
+    properties.set(parameterIndex, key);
+};
+exports.option = option;

package/dist/slashCommand/index.d.ts

@@ -0,0 +1,2 @@
+export * from './decorator';
+export * from './SlashCommand';

package/dist/slashCommand/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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("./decorator"), exports);
+__exportStar(require("./SlashCommand"), exports);

package/dist/structures/CommandClient.d.ts

@@ -1,25 +1,36 @@
 import { Registry } from './Registry';
-import { Client } from 'discord.js';
+import { Client, Snowflake } from 'discord.js';
+import { CoolDownAdapter } from '../command';
+import { REST } from '@discordjs/rest';
 export interface CommandOptions {
     prefix: string | ((msg: any) => string | Promise<string | string[]> | string[]) | string[];
 }
+export interface SlashCommandOptions {
+    guild?: Snowflake | Snowflake[];
+    autoSync: boolean;
+}
 export interface CommandClientOptions {
     command: CommandOptions;
-    owners: 'auto' | string[];
+    owners: 'auto' | Snowflake[];
+    slashCommands: SlashCommandOptions;
 }
 export interface CommandClientOptionsParam {
     command: Partial<CommandOptions>;
     owners: 'auto' | string[];
+    slashCommands: Partial<SlashCommandOptions>;
 }
 export declare class CommandClient {
     options: CommandClientOptions;
     owners: string[];
     registry: Registry;
     client: Client;
+    coolDownAdapter: CoolDownAdapter;
+    rest: REST;
     private _isReady;
     private fetchOwners;
     ready(): Promise<void>;
-    constructor({ client, ...options }: Partial<CommandClientOptionsParam> & {
+    constructor({ client, coolDownAdapter, ...options }: Partial<CommandClientOptionsParam> & {
         client: Client;
+        coolDownAdapter?: CoolDownAdapter;
     });
 }

package/dist/structures/CommandClient.js

@@ -28,42 +28,57 @@ const lodash_1 = __importDefault(require("lodash"));
 const Registry_1 = require("./Registry");
 const discord_js_1 = require("discord.js");
 const builtinModules_1 = require("../builtinModules");
+const command_1 = require("../command");
+const rest_1 = require("@discordjs/rest");
 class CommandClient {
     constructor(_a) {
-        var { client } = _a, options = __rest(_a, ["client"]);
+        var { client, coolDownAdapter } = _a, options = __rest(_a, ["client", "coolDownAdapter"]);
         this.owners = [];
         this.registry = new Registry_1.Registry(this);
+        this.rest = new rest_1.REST({
+            version: '9',
+        });
         this._isReady = false;
         this.client = client;
+        this.coolDownAdapter = coolDownAdapter || new command_1.DefaultCoolDownAdapter();
         this.options = lodash_1.default.merge(options, {
             command: {
                 prefix: '!',
             },
             owners: 'auto',
+            slashCommands: {
+                autoSync: true,
+            },
         });
-        this.client.once('ready', this.ready);
+        this.client.once('ready', () => this.ready());
         this.registry.registerModule(new builtinModules_1.CommandHandler(this.registry));
-        this.registry.registerModule(new builtinModules_1.BuiltinCommandConverters());
+        this.registry.registerModule(new builtinModules_1.BuiltinCommandConverters(this));
+        this.registry.registerModule(new builtinModules_1.BuiltinSlashCommandConverters(this));
     }
     fetchOwners() {
-        var _a;
-        const o = (_a = this.client.application) === null || _a === void 0 ? void 0 : _a.owner;
-        if (!o)
-            return [];
-        if (o instanceof discord_js_1.User)
-            return [o.id];
-        else
-            return o.members.map((x) => x.id);
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            yield ((_a = this.client.application) === null || _a === void 0 ? void 0 : _a.fetch());
+            const o = (_b = this.client.application) === null || _b === void 0 ? void 0 : _b.owner;
+            if (!o)
+                return [];
+            if (o instanceof discord_js_1.User)
+                return [o.id];
+            else
+                return o.members.map((x) => x.id);
+        });
     }
     ready() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this._isReady)
                 return;
+            this.rest.setToken(this.client.token);
             this._isReady = true;
             if (this.options.owners === 'auto') {
-                const owners = this.fetchOwners();
+                const owners = yield this.fetchOwners();
                 this.owners.push(...owners);
             }
+            yield this.registry.syncCommands();
         });
     }
 }

package/dist/structures/Module.d.ts

@@ -1,10 +1,14 @@
 import type { Command } from '../command';
 import { Listener } from '../listener';
-import { ArgumentConverter } from '../command';
+import { ArgumentConverter, SlashArgumentConverter } from '../command';
+import { SlashCommand } from '../slashCommand';
 export declare abstract class Module {
     get commands(): Command[];
     get listeners(): Listener[];
     get argumentConverters(): ArgumentConverter[];
+    get slashArgumentConverters(): SlashArgumentConverter[];
+    get slashCommands(): SlashCommand[];
+    get path(): string | undefined;
     load(): void;
     unload(): void;
     beforeReload(): void;