necord 3.0.8 → 4.0.0

package/dist/necord.update.js

@@ -11,59 +11,315 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-var NecordUpdate_1;
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NecordUpdate = void 0;
 const common_1 = require("@nestjs/common");
 const decorators_1 = require("./decorators");
-let NecordUpdate = NecordUpdate_1 = class NecordUpdate {
-    constructor() {
-        this.logger = new common_1.Logger(NecordUpdate_1.name);
+const discord_js_1 = require("discord.js");
+const necord_constants_1 = require("./necord.constants");
+const necord_registry_1 = require("./necord-registry");
+let NecordUpdate = class NecordUpdate {
+    constructor(options, client, registry) {
+        var _a;
+        this.options = options;
+        this.client = client;
+        this.registry = registry;
+        this.prefix = (_a = this.options.prefix) !== null && _a !== void 0 ? _a : '!';
+    }
+    onMessageCreate([message]) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!message || !((_a = message.content) === null || _a === void 0 ? void 0 : _a.length))
+                return;
+            const content = message.content.toLowerCase();
+            const prefix = typeof this.prefix !== 'function' ? this.prefix : yield this.prefix(message);
+            if (!prefix || !content.startsWith(prefix))
+                return;
+            const args = content.substring(prefix.length).split(/ +/g);
+            const cmd = args.shift();
+            if (!cmd)
+                return;
+            return (_b = this.registry.getTextCommand(cmd)) === null || _b === void 0 ? void 0 : _b.metadata.execute([message], args);
+        });
+    }
+    emit(event, ...args) {
+        this.client.emit(event, ...args);
     }
-    onWarn(message) {
-        if (!NecordUpdate_1.isDebugMode()) {
+    onChannelUpdate([oldChannel, newChannel]) {
+        if (!Object.prototype.hasOwnProperty.call(oldChannel, 'guild'))
             return;
+        if (oldChannel.permissionOverwrites !==
+            newChannel.permissionOverwrites) {
+            this.emit('guildChannelPermissionsUpdate', newChannel, oldChannel.permissionOverwrites, newChannel.permissionOverwrites);
+        }
+        if (oldChannel.type === 'GUILD_TEXT' &&
+            oldChannel.topic !== newChannel.topic) {
+            this.emit('guildChannelTopicUpdate', newChannel, oldChannel.topic, newChannel.topic);
         }
-        return this.logger.warn(message);
     }
-    onError(error) {
-        if (!NecordUpdate_1.isDebugMode()) {
+    onGuildMemberUpdate([oldMember, newMember]) {
+        if (oldMember.partial)
             return;
+        if (!oldMember.premiumSince && newMember.premiumSince) {
+            this.emit('guildMemberBoost', newMember);
+        }
+        if (oldMember.premiumSince && !newMember.premiumSince) {
+            this.emit('guildMemberUnboost', newMember);
+        }
+        const addedRoles = newMember.roles.cache.reduce((acc, role) => (!oldMember.roles.cache.has(role.id) ? acc.push(role) && acc : acc), []);
+        addedRoles.forEach(role => {
+            this.emit('guildMemberRoleAdd', newMember, role);
+        });
+        const removedRoles = oldMember.roles.cache.reduce((acc, role) => (!newMember.roles.cache.has(role.id) ? acc.push(role) && acc : acc), []);
+        removedRoles.forEach(role => {
+            this.emit('guildMemberRoleRemove', newMember, role);
+        });
+        if (oldMember.nickname !== newMember.nickname) {
+            this.emit('guildMemberNicknameUpdate', newMember, oldMember.nickname, newMember.nickname);
+        }
+        if (oldMember.pending !== newMember.pending) {
+            this.emit('guildMemberEntered', newMember);
+        }
+        if (!oldMember.avatar && newMember.avatar) {
+            this.emit('guildMemberAvatarAdd', newMember, newMember.avatarURL());
+        }
+        if (oldMember.avatar !== newMember.avatar) {
+            this.emit('guildMemberAvatarUpdate', newMember, oldMember.avatarURL(), newMember.avatarURL());
+        }
+        if (oldMember.avatar && !newMember.avatar) {
+            this.emit('guildMemberAvatarRemove', newMember, oldMember.avatarURL());
         }
-        return this.logger.error(error);
     }
-    onDebug(message) {
-        if (!NecordUpdate_1.isDebugMode()) {
+    onGuildUpdate([oldGuild, newGuild]) {
+        if (oldGuild.premiumTier < newGuild.premiumTier) {
+            this.emit('guildBoostLevelUp', newGuild, oldGuild.premiumTier, newGuild.premiumTier);
+        }
+        if (oldGuild.premiumTier > newGuild.premiumTier) {
+            this.emit('guildBoostLevelDown', oldGuild, newGuild);
+        }
+        if (!oldGuild.banner && newGuild.banner) {
+            this.emit('guildBannerAdd', newGuild, newGuild.bannerURL());
+        }
+        if (!oldGuild.afkChannel && newGuild.afkChannel) {
+            this.emit('guildAfkChannelAdd', newGuild, newGuild.afkChannel);
+        }
+        if (!oldGuild.vanityURLCode && newGuild.vanityURLCode) {
+            this.emit('guildVanityURLAdd', newGuild, newGuild.vanityURLCode);
+        }
+        if (oldGuild.vanityURLCode !== newGuild.vanityURLCode) {
+            this.emit('guildVanityURLUpdate', newGuild, oldGuild.vanityURLCode, newGuild.vanityURLCode);
+        }
+        if (oldGuild.vanityURLCode && !newGuild.vanityURLCode) {
+            this.emit('guildVanityURLRemove', newGuild, oldGuild.vanityURLCode);
+        }
+        if (oldGuild.features.length !== newGuild.features.length) {
+            this.emit('guildFeaturesUpdate', newGuild, oldGuild.features, newGuild.features);
+        }
+        if (oldGuild.nameAcronym !== newGuild.nameAcronym) {
+            this.emit('guildAcronymUpdate', oldGuild, newGuild);
+        }
+        if (oldGuild.ownerId !== newGuild.ownerId) {
+            this.emit('guildOwnerUpdate', oldGuild, newGuild);
+        }
+        if (!oldGuild.partnered && newGuild.partnered) {
+            this.emit('guildPartnerAdd', newGuild);
+        }
+        if (oldGuild.partnered && !newGuild.partnered) {
+            this.emit('guildPartnerRemove', newGuild);
+        }
+        if (!oldGuild.verified && newGuild.verified) {
+            this.emit('guildVerificationAdd', newGuild);
+        }
+        if (oldGuild.verified && !newGuild.verified) {
+            this.emit('guildVerificationRemove', newGuild);
+        }
+    }
+    onMessageUpdate([oldMessage, newMessage]) {
+        if (oldMessage.partial || newMessage.partial)
             return;
+        if (!oldMessage.pinned && newMessage.pinned) {
+            this.emit('messagePinned', newMessage);
+        }
+        if (oldMessage.content !== newMessage.content) {
+            this.emit('messageContentEdited', newMessage, oldMessage.content, newMessage.content);
         }
-        return this.logger.debug(message);
     }
-    static isDebugMode() {
-        return !!process.env.NEST_DEBUG;
+    onPresenceUpdate([oldPresence, newPresence]) {
+        if (!oldPresence)
+            return;
+        if (oldPresence.status !== 'offline' && newPresence.status === 'offline') {
+            this.emit('guildMemberOffline', newPresence.member, oldPresence.status);
+        }
+        if (oldPresence.status === 'offline' && newPresence.status !== 'offline') {
+            this.emit('guildMemberOnline', newPresence.member, newPresence.status);
+        }
+    }
+    onRoleUpdate([oldRole, newRole]) {
+        if (oldRole.rawPosition !== newRole.rawPosition) {
+            this.emit('rolePositionUpdate', newRole, oldRole.rawPosition, newRole.rawPosition);
+        }
+        if (oldRole.permissions.bitfield !== newRole.permissions.bitfield) {
+            this.emit('rolePermissionsUpdate', newRole, oldRole.permissions, newRole.permissions);
+        }
+        if (!oldRole.icon && newRole.icon) {
+            this.emit('roleIconAdd', newRole, newRole.iconURL());
+        }
+        if (oldRole.icon !== newRole.icon) {
+            this.emit('roleIconUpdate', newRole, oldRole.iconURL(), newRole.iconURL());
+        }
+        if (oldRole.icon && !newRole.icon) {
+            this.emit('roleIconRemove', newRole, oldRole.iconURL());
+        }
+    }
+    onThreadUpdate([oldThread, newThread]) {
+        if (!Object.prototype.hasOwnProperty.call(oldThread, 'guild'))
+            return;
+        if (oldThread.archived !== newThread.archived) {
+            this.emit('threadStateUpdate', oldThread, newThread);
+        }
+        if (oldThread.name !== newThread.name) {
+            this.emit('threadNameUpdate', newThread, oldThread.name, newThread.name);
+        }
+        if (oldThread.locked !== newThread.locked) {
+            this.emit('threadLockStateUpdate', oldThread, newThread);
+        }
+        if (oldThread.rateLimitPerUser !== newThread.rateLimitPerUser) {
+            this.emit('threadRateLimitPerUserUpdate', newThread, oldThread.rateLimitPerUser, newThread.rateLimitPerUser);
+        }
+        if (oldThread.autoArchiveDuration !== newThread.autoArchiveDuration) {
+            this.emit('threadAutoArchiveDurationUpdate', newThread, oldThread.autoArchiveDuration, newThread.autoArchiveDuration);
+        }
+    }
+    onUserUpdate([oldUser, newUser]) {
+        if (oldUser.partial)
+            return;
+        if (oldUser.displayAvatarURL() !== newUser.displayAvatarURL()) {
+            this.emit('userAvatarUpdate', newUser, oldUser.displayAvatarURL(), newUser.displayAvatarURL());
+        }
+        if (oldUser.username !== newUser.username) {
+            this.emit('userUsernameUpdate', newUser, oldUser.username, newUser.username);
+        }
+        if (oldUser.discriminator !== newUser.discriminator) {
+            this.emit('userDiscriminatorUpdate', newUser, oldUser.discriminator, newUser.discriminator);
+        }
+        if (oldUser.flags !== newUser.flags) {
+            this.emit('userFlagsUpdate', newUser, oldUser.flags, newUser.flags);
+        }
+    }
+    onVoiceStateUpdate([oldState, newState]) {
+        const newMember = newState.member;
+        if (!oldState.channel && newState.channel) {
+            this.emit('voiceChannelJoin', newMember, newState.channel);
+        }
+        if (oldState.channel && newState.channel && oldState.channel.id !== newState.channel.id) {
+            this.emit('voiceChannelSwitch', newMember, oldState.channel, newState.channel);
+        }
+        if (oldState.channel && !newState.channel) {
+            this.emit('voiceChannelLeave', newMember, oldState.channel);
+        }
+        if (!oldState.mute && newState.mute) {
+            this.emit('voiceChannelMute', newMember, newState.selfMute ? 'self-muted' : 'server-muted');
+        }
+        if (oldState.mute && !newState.mute) {
+            this.emit('voiceChannelUnmute', newMember, oldState.selfMute ? 'self-muted' : 'server-muted');
+        }
+        if (!oldState.deaf && newState.deaf) {
+            this.emit('voiceChannelDeaf', newMember, newState.selfDeaf ? 'self-deafed' : 'server-deafed');
+        }
+        if (oldState.deaf && !newState.deaf) {
+            this.emit('voiceChannelUndeaf', newMember, oldState.selfDeaf ? 'self-deafed' : 'server-deafed');
+        }
+        if (!oldState.streaming && newState.streaming) {
+            this.emit('voiceStreamingStart', newMember, newState.channel);
+        }
+        if (oldState.streaming && !newState.streaming) {
+            this.emit('voiceStreamingStop', newMember, newState.channel);
+        }
     }
 };
 __decorate([
-    (0, decorators_1.On)('warn'),
+    (0, decorators_1.On)('messageCreate'),
+    __param(0, (0, decorators_1.Context)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], NecordUpdate.prototype, "onMessageCreate", null);
+__decorate([
+    (0, decorators_1.On)('channelUpdate'),
+    __param(0, (0, decorators_1.Context)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], NecordUpdate.prototype, "onChannelUpdate", null);
+__decorate([
+    (0, decorators_1.On)('guildMemberUpdate'),
+    __param(0, (0, decorators_1.Context)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], NecordUpdate.prototype, "onGuildMemberUpdate", null);
+__decorate([
+    (0, decorators_1.On)('guildUpdate'),
+    __param(0, (0, decorators_1.Context)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], NecordUpdate.prototype, "onGuildUpdate", null);
+__decorate([
+    (0, decorators_1.On)('messageUpdate'),
+    __param(0, (0, decorators_1.Context)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], NecordUpdate.prototype, "onMessageUpdate", null);
+__decorate([
+    (0, decorators_1.On)('presenceUpdate'),
+    __param(0, (0, decorators_1.Context)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], NecordUpdate.prototype, "onPresenceUpdate", null);
+__decorate([
+    (0, decorators_1.On)('roleUpdate'),
+    __param(0, (0, decorators_1.Context)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], NecordUpdate.prototype, "onRoleUpdate", null);
+__decorate([
+    (0, decorators_1.On)('threadUpdate'),
     __param(0, (0, decorators_1.Context)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
+    __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", void 0)
-], NecordUpdate.prototype, "onWarn", null);
+], NecordUpdate.prototype, "onThreadUpdate", null);
 __decorate([
-    (0, decorators_1.On)('error'),
+    (0, decorators_1.On)('userUpdate'),
     __param(0, (0, decorators_1.Context)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Error]),
+    __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", void 0)
-], NecordUpdate.prototype, "onError", null);
+], NecordUpdate.prototype, "onUserUpdate", null);
 __decorate([
-    (0, decorators_1.On)('debug'),
+    (0, decorators_1.On)('voiceStateUpdate'),
     __param(0, (0, decorators_1.Context)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
+    __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", void 0)
-], NecordUpdate.prototype, "onDebug", null);
-NecordUpdate = NecordUpdate_1 = __decorate([
-    (0, common_1.Injectable)()
+], NecordUpdate.prototype, "onVoiceStateUpdate", null);
+NecordUpdate = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(necord_constants_1.NECORD_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [Object, discord_js_1.Client,
+        necord_registry_1.NecordRegistry])
 ], NecordUpdate);
 exports.NecordUpdate = NecordUpdate;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "necord",
 	"description": "A module for creating Discord bots using NestJS, based on Discord.js.",
-	"version": "3.0.8",
+	"version": "4.0.0",
 	"scripts": {
 		"build": "rimraf -rf dist && tsc -p tsconfig.json",
 		"prepublish:npm": "npm run build",
@@ -9,9 +9,12 @@
 		"prepublish:dev": "npm run build",
 		"publish:dev": "npm publish --access public --tag dev",
 		"prepare": "husky install .github/husky",
-		"test": "echo add tests",
 		"format": "prettier --write \"src/**/*.ts\"",
-		"lint": "eslint --ignore-path .gitignore {integration,src}/**/*.ts"
+		"lint": "eslint --ignore-path .gitignore src/**/*.ts"
+	},
+	"directories": {
+		"lib": "src",
+		"test": "test"
 	},
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",
@@ -42,24 +45,25 @@
 	],
 	"dependencies": {},
 	"devDependencies": {
-		"@commitlint/cli": "16.0.0",
+		"@commitlint/cli": "16.0.2",
 		"@commitlint/config-angular": "16.0.0",
 		"@favware/npm-deprecate": "1.0.4",
 		"@nestjs/common": "8.2.4",
 		"@nestjs/core": "8.2.4",
-		"@types/node": "17.0.5",
+		"@types/node": "17.0.8",
 		"@typescript-eslint/eslint-plugin": "4.33.0",
 		"@typescript-eslint/parser": "4.33.0",
-		"discord.js": "13.3.1",
+		"discord.js": "13.5.1",
 		"eslint": "7.32.0",
 		"eslint-config-prettier": "8.3.0",
 		"eslint-plugin-prettier": "4.0.0",
 		"husky": "7.0.4",
 		"prettier": "2.5.1",
 		"reflect-metadata": "0.1.13",
-		"release-it": "14.11.8",
+		"release-it": "14.12.1",
 		"rimraf": "3.0.2",
-		"rxjs": "7.4.0",
+		"rxjs": "7.5.1",
+		"ts-node": "^10.4.0",
 		"typescript": "4.5.4"
 	},
 	"peerDependencies": {

package/dist/context/necord-paramtype.enum.d.ts

@@ -1,6 +0,0 @@
-export declare enum NecordParamType {
-    CONTEXT = 0,
-    VALUES = 1,
-    OPTIONS = 2,
-    COMPONENT = 3
-}

package/dist/context/necord-paramtype.enum.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NecordParamType = void 0;
-var NecordParamType;
-(function (NecordParamType) {
-    NecordParamType[NecordParamType["CONTEXT"] = 0] = "CONTEXT";
-    NecordParamType[NecordParamType["VALUES"] = 1] = "VALUES";
-    NecordParamType[NecordParamType["OPTIONS"] = 2] = "OPTIONS";
-    NecordParamType[NecordParamType["COMPONENT"] = 3] = "COMPONENT";
-})(NecordParamType = exports.NecordParamType || (exports.NecordParamType = {}));

package/dist/decorators/groups.decorator.d.ts

@@ -1,3 +0,0 @@
-import { ApplicationCommandSubGroupData, ChatInputApplicationCommandData } from 'discord.js';
-export declare const CommandGroup: (data?: Omit<ChatInputApplicationCommandData, 'type' | 'options'>) => import("@nestjs/common").CustomDecorator<string>;
-export declare const CommandSubGroup: (data?: Omit<ApplicationCommandSubGroupData, 'type' | 'options'>) => import("@nestjs/common").CustomDecorator<string>;

package/dist/decorators/groups.decorator.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommandSubGroup = exports.CommandGroup = void 0;
-const common_1 = require("@nestjs/common");
-const necord_constants_1 = require("../necord.constants");
-const CommandGroup = (data) => (0, common_1.SetMetadata)(necord_constants_1.GROUP_METADATA, Object.assign({ type: 1 /* CHAT_INPUT */, options: [] }, data));
-exports.CommandGroup = CommandGroup;
-const CommandSubGroup = (data) => (0, common_1.SetMetadata)(necord_constants_1.SUBGROUP_METADATA, Object.assign({ type: 2 /* SUB_COMMAND_GROUP */, options: [] }, data));
-exports.CommandSubGroup = CommandSubGroup;

package/dist/interfaces/command-metadata.interface.d.ts

@@ -1,6 +0,0 @@
-import { ApplicationCommandData } from 'discord.js';
-export declare type ApplicationCommandMetadata = ApplicationCommandData & {
-    instance?: Record<string, any>;
-    prototype?: object;
-    method?: string;
-};

package/dist/interfaces/component-metadata.interface.d.ts

@@ -1,5 +0,0 @@
-import { MessageComponentTypes } from 'discord.js/typings/enums';
-export interface ComponentMetadata {
-    type: MessageComponentTypes;
-    customId: string;
-}

package/dist/interfaces/listener-metadata.interface.d.ts

@@ -1,5 +0,0 @@
-import { ClientEvents } from 'discord.js';
-export interface ListenerMetadata<U extends keyof ClientEvents = keyof ClientEvents> {
-    event: U;
-    type: 'once' | 'on';
-}

package/dist/interfaces/module-options.interface.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/option-metadata.interface.d.ts

@@ -1,7 +0,0 @@
-import { ApplicationCommandOptionData, ApplicationCommandSubCommandData, ApplicationCommandSubGroupData, CommandInteractionOptionResolver } from 'discord.js';
-export declare type OptionData = Exclude<ApplicationCommandOptionData, ApplicationCommandSubGroupData | ApplicationCommandSubCommandData>;
-export declare type OptionTransform = keyof CommandInteractionOptionResolver;
-export declare type OptionMetadata<T extends OptionData['type'] = OptionData['type']> = OptionData & {
-    readonly type?: T;
-    methodName?: OptionTransform;
-};

package/dist/interfaces/option-metadata.interface.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/commands.service.d.ts

@@ -1,19 +0,0 @@
-import { OnModuleInit } from '@nestjs/common';
-import { ExplorerService } from './explorer.service';
-import { ApplicationCommandMetadata, NecordModuleOptions } from '../interfaces';
-import { MetadataAccessorService } from './metadata-accessor.service';
-import { Client } from 'discord.js';
-export declare class CommandsService implements OnModuleInit {
-    private readonly explorerService;
-    private readonly metadataAccessor;
-    private readonly client;
-    private readonly options;
-    private readonly logger;
-    private readonly commands;
-    constructor(explorerService: ExplorerService<ApplicationCommandMetadata>, metadataAccessor: MetadataAccessorService, client: Client, options: NecordModuleOptions);
-    onModuleInit(): Promise<void>;
-    private onReadyRegistration;
-    private registerContextMenuHandler;
-    private registerSlashCommandHandler;
-    private static getCommandKey;
-}

package/dist/services/commands.service.js

@@ -1,169 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-var CommandsService_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommandsService = void 0;
-const common_1 = require("@nestjs/common");
-const explorer_service_1 = require("./explorer.service");
-const metadata_accessor_service_1 = require("./metadata-accessor.service");
-const discord_js_1 = require("discord.js");
-const decorators_1 = require("../decorators");
-const necord_constants_1 = require("../necord.constants");
-let CommandsService = CommandsService_1 = class CommandsService {
-    constructor(explorerService, metadataAccessor, client, options) {
-        this.explorerService = explorerService;
-        this.metadataAccessor = metadataAccessor;
-        this.client = client;
-        this.options = options;
-        this.logger = new common_1.Logger(CommandsService_1.name);
-        this.commands = [];
-    }
-    onModuleInit() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const commands = this.explorerService.explore((instance, prototype, method) => {
-                const command = this.metadataAccessor.getApplicationCommandMetadata(instance, method);
-                if (!command)
-                    return;
-                return Object.assign(Object.assign({}, command), { instance,
-                    prototype,
-                    method });
-            });
-            for (let _a of commands) {
-                const { instance, prototype, method } = _a, command = __rest(_a, ["instance", "prototype", "method"]);
-                const options = this.metadataAccessor.getOptionsMetadata(instance, method);
-                let group = this.metadataAccessor.getCommandGroupMetadata(instance, method);
-                let subGroup = this.metadataAccessor.getCommandSubGroupMetadata(instance, method);
-                if (command.type !== 1 /* CHAT_INPUT */) {
-                    this.commands.push(command);
-                    this.registerContextMenuHandler(command, command.execute);
-                    continue;
-                }
-                else if (!group && subGroup) {
-                    subGroup = undefined;
-                }
-                command.options = Object.values(options);
-                this.registerSlashCommandHandler(group === null || group === void 0 ? void 0 : group.name, subGroup === null || subGroup === void 0 ? void 0 : subGroup.name, command, options, command.execute);
-                if (!group && !subGroup) {
-                    this.commands.push(command);
-                    continue;
-                }
-                const cachedGroup = this.commands.find(c => c.type === 1 /* CHAT_INPUT */ && c.name === group.name);
-                group = cachedGroup !== null && cachedGroup !== void 0 ? cachedGroup : group;
-                if (!subGroup) {
-                    group.options.push(command);
-                }
-                else {
-                    const cachedSubGroup = group.options.find(s => s.type === 2 /* SUB_COMMAND_GROUP */ && s.name === (subGroup === null || subGroup === void 0 ? void 0 : subGroup.name));
-                    subGroup = cachedSubGroup !== null && cachedSubGroup !== void 0 ? cachedSubGroup : subGroup;
-                    subGroup.options.push(command);
-                    !cachedSubGroup && group.options.push(subGroup);
-                }
-                !cachedGroup && this.commands.push(group);
-            }
-        });
-    }
-    onReadyRegistration() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.options.registerApplicationCommands) {
-                return;
-            }
-            if (this.client.application.partial) {
-                yield this.client.application.fetch();
-            }
-            this.logger.log(`Started refreshing application commands.`);
-            yield this.client.application.commands.set(this.commands, typeof this.options.registerApplicationCommands === 'string'
-                ? this.options.registerApplicationCommands
-                : undefined);
-            this.logger.log(`Successfully reloaded application commands.`);
-        });
-    }
-    registerContextMenuHandler(command, execute) {
-        this.client.on('interactionCreate', interaction => interaction.isContextMenu() &&
-            interaction.targetType === (command.type === 2 /* USER */ ? 'USER' : 'MESSAGE') &&
-            interaction.commandName === command.name &&
-            execute(interaction, interaction.targetType === 'USER'
-                ? {
-                    user: interaction.options.getUser('user'),
-                    member: interaction.options.getMember('user')
-                }
-                : { message: interaction.options.getMessage('message') }));
-    }
-    registerSlashCommandHandler(group, subGroup, command, options, execute) {
-        this.client.on('interactionCreate', (interaction) => __awaiter(this, void 0, void 0, function* () {
-            if (!interaction.isCommand())
-                return;
-            const rootCommand = interaction.commandName;
-            const groupCommand = interaction.options.getSubcommandGroup(false);
-            const subCommandGroup = interaction.options.getSubcommand(false);
-            if (CommandsService_1.getCommandKey(rootCommand, groupCommand, subCommandGroup) !==
-                CommandsService_1.getCommandKey(group, subGroup, command.name))
-                return;
-            const DTO = Object.entries(options).reduce((prev, [parameter, option]) => {
-                const resolve = interaction.options[option.methodName];
-                prev[parameter] = resolve.call(interaction.options, option.name, !!option.required);
-                return prev;
-            }, {});
-            return execute(interaction, DTO);
-        }));
-    }
-    static getCommandKey(group, subGroup, command) {
-        let commandKey;
-        if (!!group) {
-            if (!!subGroup) {
-                commandKey = `${group}-${subGroup}-${command}`;
-            }
-            else {
-                commandKey = `${group}-null-${command}`;
-            }
-        }
-        else {
-            commandKey = `${command}-null-null`;
-        }
-        return commandKey;
-    }
-};
-__decorate([
-    (0, decorators_1.On)('ready'),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], CommandsService.prototype, "onReadyRegistration", null);
-CommandsService = CommandsService_1 = __decorate([
-    (0, common_1.Injectable)(),
-    __param(3, (0, common_1.Inject)(necord_constants_1.NECORD_MODULE_OPTIONS)),
-    __metadata("design:paramtypes", [explorer_service_1.ExplorerService,
-        metadata_accessor_service_1.MetadataAccessorService,
-        discord_js_1.Client, Object])
-], CommandsService);
-exports.CommandsService = CommandsService;