seyfert 2.1.0 → 2.1.1-dev-11310514874.0

package/lib/commands/applications/menucontext.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MenuCommandContext = void 0;
-const types_1 = require("../../types");
+const transformers_1 = require("../../client/transformers");
 const common_1 = require("../../common");
+const types_1 = require("../../types");
 const basecontext_1 = require("../basecontext");
-const transformers_1 = require("../../client/transformers");
 class MenuCommandContext extends basecontext_1.BaseContext {
     client;
     interaction;
@@ -38,8 +38,8 @@ class MenuCommandContext extends basecontext_1.BaseContext {
     get fullCommandName() {
         return this.command.name;
     }
-    write(body, fetchReply) {
-        return this.interaction.write(body, fetchReply);
+    write(body, withResponse) {
+        return this.interaction.write(body, withResponse);
     }
     modal(body) {
         return this.interaction.modal(body);
@@ -53,8 +53,8 @@ class MenuCommandContext extends basecontext_1.BaseContext {
     deleteResponse() {
         return this.interaction.deleteResponse();
     }
-    editOrReply(body, fetchReply) {
-        return this.interaction.editOrReply(body, fetchReply);
+    editOrReply(body, withResponse) {
+        return this.interaction.editOrReply(body, withResponse);
     }
     fetchResponse() {
         return this.interaction.fetchResponse();

package/lib/commands/applications/options.d.ts

@@ -1,11 +1,11 @@
-import { ApplicationCommandOptionType, type APIApplicationCommandOptionChoice, type ChannelType } from '../../types';
 import type { AutocompleteCallback, EntryPointContext, MenuCommandContext, OnAutocompleteErrorCallback, ReturnOptionsTypes, __TypesWrapper } from '..';
+import type { ModalContext } from '../../components';
+import type { ComponentContext } from '../../components/componentcontext';
 import type { MessageCommandInteraction, UserCommandInteraction } from '../../structures';
+import { type APIApplicationCommandOptionChoice, ApplicationCommandOptionType, type ChannelType } from '../../types';
 import type { CommandContext } from './chatcontext';
 import type { MiddlewareContext } from './shared';
-import type { ModalContext } from '../../components';
-import type { ComponentContext } from '../../components/componentcontext';
-export type SeyfertBasicOption<T extends keyof __TypesWrapper, D = {}> = __TypesWrapper[T] & D;
+export type SeyfertBasicOption<T extends keyof __TypesWrapper, D = object> = __TypesWrapper[T] & D;
 export type SeyfertStringOption = SeyfertBasicOption<'String'> & {
     autocomplete?: AutocompleteCallback;
     onAutocompleteError?: OnAutocompleteErrorCallback;

package/lib/commands/applications/shared.d.ts

@@ -20,6 +20,9 @@ export interface ExtraProps {
 export interface UsingClient extends BaseClient {
 }
 export type ParseClient<T extends BaseClient> = T;
+export type ParseGlobalMiddlewares<T extends Record<string, MiddlewareContext>> = {
+    [K in keyof T]: MetadataMiddleware<T[K]>;
+};
 export interface InternalOptions {
 }
 export interface CustomStructures {
@@ -34,9 +37,9 @@ export type MetadataMiddleware<T extends MiddlewareContext> = IsStrictlyUndefine
 export type CommandMetadata<T extends readonly (keyof RegisteredMiddlewares)[]> = T extends readonly [
     infer first,
     ...infer rest
-] ? first extends keyof RegisteredMiddlewares ? (MetadataMiddleware<RegisteredMiddlewares[first]> extends never ? {} : {
+] ? first extends keyof RegisteredMiddlewares ? (MetadataMiddleware<RegisteredMiddlewares[first]> extends never ? never : {
     [key in first]: MetadataMiddleware<RegisteredMiddlewares[first]>;
-}) & (rest extends readonly (keyof RegisteredMiddlewares)[] ? CommandMetadata<rest> : {}) : {} : {};
+}) & (rest extends readonly (keyof RegisteredMiddlewares)[] ? CommandMetadata<rest> : never) : never : never;
 export type MessageCommandOptionErrors = ['CHANNEL_TYPES', type: ChannelType[]] | ['STRING_MIN_LENGTH', min: number] | ['STRING_MAX_LENGTH', max: number] | ['STRING_INVALID_CHOICE', choices: readonly {
     name: string;
     value: string;

package/lib/commands/basecontext.d.ts

@@ -1,5 +1,5 @@
 import type { ModalContext } from '../components';
-import type { ContextComponentCommandInteractionMap, ComponentContext } from '../components/componentcontext';
+import type { ComponentContext, ContextComponentCommandInteractionMap } from '../components/componentcontext';
 import type { MessageCommandInteraction, UserCommandInteraction } from '../structures';
 import type { CommandContext } from './applications/chatcontext';
 import type { MenuCommandContext } from './applications/menucontext';

package/lib/commands/decorators.d.ts

@@ -1,5 +1,5 @@
-import { ApplicationCommandType, ApplicationIntegrationType, type EntryPointCommandHandlerType, InteractionContextType, type LocaleString } from '../types';
 import type { FlatObjectKeys, PermissionStrings } from '../common';
+import { ApplicationCommandType, ApplicationIntegrationType, type EntryPointCommandHandlerType, InteractionContextType, type LocaleString } from '../types';
 import type { CommandOption, OptionsRecord, SubCommand } from './applications/chat';
 import type { DefaultLocale, ExtraProps, IgnoreCommand, MiddlewareContext } from './applications/shared';
 export interface RegisteredMiddlewares {
@@ -27,7 +27,7 @@ export declare function Locales({ name: names, description: descriptions, }: {
     name?: [language: LocaleString, value: string][];
     description?: [language: LocaleString, value: string][];
 }): <T extends {
-    new (...args: any[]): {};
+    new (...args: any[]): object;
 }>(target: T) => {
     new (...args: any[]): {
         name_localizations: {
@@ -39,7 +39,7 @@ export declare function Locales({ name: names, description: descriptions, }: {
     };
 } & T;
 export declare function LocalesT(name?: FlatObjectKeys<DefaultLocale>, description?: FlatObjectKeys<DefaultLocale>): <T extends {
-    new (...args: any[]): {};
+    new (...args: any[]): object;
 }>(target: T) => {
     new (...args: any[]): {
         __t: {
@@ -54,7 +54,7 @@ export declare function GroupsT(groups: Record<string, {
     defaultDescription: string;
     aliases?: string[];
 }>): <T extends {
-    new (...args: any[]): {};
+    new (...args: any[]): object;
 }>(target: T) => {
     new (...args: any[]): {
         __tGroups: Record<string, {
@@ -72,7 +72,7 @@ export declare function Groups(groups: Record<string, {
     defaultDescription: string;
     aliases?: string[];
 }>): <T extends {
-    new (...args: any[]): {};
+    new (...args: any[]): object;
 }>(target: T) => {
     new (...args: any[]): {
         groups: Record<string, {
@@ -85,21 +85,21 @@ export declare function Groups(groups: Record<string, {
     };
 } & T;
 export declare function Group(groupName: string): <T extends {
-    new (...args: any[]): {};
+    new (...args: any[]): object;
 }>(target: T) => {
     new (...args: any[]): {
         group: string;
     };
 } & T;
 export declare function Options(options: (new () => SubCommand)[] | OptionsRecord): <T extends {
-    new (...args: any[]): {};
+    new (...args: any[]): object;
 }>(target: T) => {
     new (...args: any[]): {
         options: SubCommand[] | CommandOption[];
     };
 } & T;
 export declare function AutoLoad(): <T extends {
-    new (...args: any[]): {};
+    new (...args: any[]): object;
 }>(target: T) => {
     new (...args: any[]): {
         __autoload: boolean;
@@ -109,14 +109,14 @@ export type ParseMiddlewares<T extends Record<string, MiddlewareContext>> = {
     [k in keyof T]: T[k];
 };
 export declare function Middlewares(cbs: readonly (keyof RegisteredMiddlewares)[]): <T extends {
-    new (...args: any[]): {};
+    new (...args: any[]): object;
 }>(target: T) => {
     new (...args: any[]): {
         middlewares: readonly never[];
     };
 } & T;
 export declare function Declare(declare: CommandDeclareOptions): <T extends {
-    new (...args: any[]): {};
+    new (...args: any[]): object;
 }>(target: T) => {
     new (...args: any[]): {
         name: string;

package/lib/commands/decorators.js

@@ -9,6 +9,7 @@ exports.Options = Options;
 exports.AutoLoad = AutoLoad;
 exports.Middlewares = Middlewares;
 exports.Declare = Declare;
+const Permissions_1 = require("../structures/extra/Permissions");
 const types_1 = require("../types");
 function Locales({ name: names, description: descriptions, }) {
     return (target) => class extends target {
@@ -86,11 +87,11 @@ function Declare(declare) {
         integrationTypes = declare.integrationTypes?.map(i => types_1.ApplicationIntegrationType[i]) ?? [
             types_1.ApplicationIntegrationType.GuildInstall,
         ];
-        defaultMemberPermissions = Array.isArray(declare.defaultMemberPermissions)
-            ? declare.defaultMemberPermissions?.reduce((acc, prev) => acc | types_1.PermissionFlagsBits[prev], BigInt(0))
+        defaultMemberPermissions = declare.defaultMemberPermissions
+            ? Permissions_1.PermissionsBitField.resolve(declare.defaultMemberPermissions)
             : declare.defaultMemberPermissions;
-        botPermissions = Array.isArray(declare.botPermissions)
-            ? declare.botPermissions?.reduce((acc, prev) => acc | types_1.PermissionFlagsBits[prev], BigInt(0))
+        botPermissions = declare.botPermissions
+            ? Permissions_1.PermissionsBitField.resolve(declare.botPermissions)
             : declare.botPermissions;
         description = '';
         type = types_1.ApplicationCommandType.ChatInput;

package/lib/commands/handle.d.ts

@@ -1,9 +1,9 @@
-import { type APIApplicationCommandInteraction, type APIInteraction, type GatewayMessageCreateDispatchData, type APIApplicationCommandInteractionDataOption, ApplicationCommandOptionType } from '../types';
-import { Command, type ContextOptionsResolved, type UsingClient, type CommandAutocompleteOption, type ContextMenuCommand, MenuCommandContext, CommandContext, SubCommand, type CommandOption, type MessageCommandOptionErrors, EntryPointContext, type EntryPointCommand } from '.';
-import { AutocompleteInteraction, type ComponentInteraction, type ModalSubmitInteraction, type ChatInputCommandInteraction, type MessageCommandInteraction, type UserCommandInteraction, type __InternalReplyFunction, type EntryPointInteraction } from '../structures';
-import type { PermissionsBitField } from '../structures/extra/Permissions';
+import { Command, type CommandAutocompleteOption, CommandContext, type CommandOption, type ContextMenuCommand, type ContextOptionsResolved, type EntryPointCommand, EntryPointContext, MenuCommandContext, type MessageCommandOptionErrors, SubCommand, type UsingClient } from '.';
+import { type MessageStructure, type OptionResolverStructure, Transformers } from '../client/transformers';
 import type { MakeRequired } from '../common';
-import { type MessageStructure, Transformers, type OptionResolverStructure } from '../client/transformers';
+import { AutocompleteInteraction, type ChatInputCommandInteraction, type ComponentInteraction, type EntryPointInteraction, type MessageCommandInteraction, type ModalSubmitInteraction, type UserCommandInteraction, type __InternalReplyFunction } from '../structures';
+import type { PermissionsBitField } from '../structures/extra/Permissions';
+import { type APIApplicationCommandInteraction, type APIApplicationCommandInteractionDataOption, type APIInteraction, ApplicationCommandOptionType, type GatewayMessageCreateDispatchData } from '../types';
 export type CommandOptionWithType = CommandOption & {
     type: ApplicationCommandOptionType;
 };
@@ -36,10 +36,10 @@ export declare class HandleCommand {
         name: string;
     }): T | undefined;
     checkPermissions(app: PermissionsBitField, bot: bigint): import("../common").PermissionStrings | undefined;
-    fetchChannel(_option: CommandOptionWithType, query: string): Promise<import("../types").APIChannel | null>;
-    fetchUser(_option: CommandOptionWithType, query: string): Promise<import("../types").APIUser | null>;
-    fetchMember(_option: CommandOptionWithType, query: string, guildId: string): Promise<import("../types").APIGuildMember | null>;
-    fetchRole(_option: CommandOptionWithType, query: string, guildId?: string): Promise<import("../types").APIRole | null | undefined>;
+    fetchChannel(_option: CommandOptionWithType, query: string): Promise<import("../types").APIChannel> | null;
+    fetchUser(_option: CommandOptionWithType, query: string): Promise<import("../types").APIUser> | null;
+    fetchMember(_option: CommandOptionWithType, query: string, guildId: string): Promise<import("../types").APIGuildMember> | null;
+    fetchRole(_option: CommandOptionWithType, query: string, guildId?: string): Promise<import("../types").APIRole> | null;
     runGlobalMiddlewares(command: Command | ContextMenuCommand | SubCommand | EntryPointCommand, context: CommandContext<{}, never> | MenuCommandContext<any> | EntryPointContext): Promise<false | {
         error?: string;
         pass?: boolean;

package/lib/commands/handle.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HandleCommand = void 0;
-const types_1 = require("../types");
 const _1 = require(".");
-const structures_1 = require("../structures");
-const components_1 = require("../components");
 const transformers_1 = require("../client/transformers");
+const components_1 = require("../components");
+const structures_1 = require("../structures");
+const types_1 = require("../types");
 class HandleCommand {
     client;
     constructor(client) {
@@ -40,7 +40,7 @@ class HandleCommand {
         return this.contextMenuUser(command, interaction, context);
     }
     async contextMenuUser(command, interaction, context) {
-        if (command.botPermissions && interaction.appPermissions) {
+        if (context.guildId && command.botPermissions && interaction.appPermissions) {
             const permissions = this.checkPermissions(interaction.appPermissions, command.botPermissions);
             if (permissions)
                 return command.onBotPermissionsFail(context, permissions);
@@ -71,10 +71,10 @@ class HandleCommand {
         }
     }
     async entryPoint(command, interaction, context) {
-        if (command.botPermissions && interaction.appPermissions) {
+        if (context.guildId && command.botPermissions && interaction.appPermissions) {
             const permissions = this.checkPermissions(interaction.appPermissions, command.botPermissions);
             if (permissions)
-                return command.onBotPermissionsFail?.(context, permissions);
+                return command.onBotPermissionsFail(context, permissions);
         }
         const resultGlobal = await this.runGlobalMiddlewares(command, context);
         if (typeof resultGlobal === 'boolean')
@@ -102,10 +102,17 @@ class HandleCommand {
         }
     }
     async chatInput(command, interaction, resolver, context) {
-        if (command.botPermissions && interaction.appPermissions) {
-            const permissions = this.checkPermissions(interaction.appPermissions, command.botPermissions);
-            if (permissions)
-                return command.onBotPermissionsFail?.(context, permissions);
+        if (context.guildId && interaction.appPermissions) {
+            if (command.botPermissions) {
+                const permissions = this.checkPermissions(interaction.appPermissions, command.botPermissions);
+                if (permissions)
+                    return command.onBotPermissionsFail?.(context, permissions);
+            }
+            if (command.defaultMemberPermissions) {
+                const permissions = this.checkPermissions(interaction.member.permissions, command.defaultMemberPermissions);
+                if (permissions)
+                    return command.onPermissionsFail?.(context, permissions);
+            }
         }
         if (!(await this.runOptions(command, context, resolver)))
             return;
@@ -164,8 +171,9 @@ class HandleCommand {
                         const data = this.makeMenuCommand(body, shardId, __reply);
                         if (!data)
                             return;
+                        this.contextMenuMessage(data.command, 
                         // @ts-expect-error
-                        this.contextMenuMessage(data.command, data.interaction, data.context);
+                        data.interaction, data.context);
                         break;
                     }
                     case types_1.ApplicationCommandType.User: {
@@ -285,7 +293,7 @@ class HandleCommand {
                 if (command.botPermissions) {
                     const appPermissions = await self.members.permissions(rawMessage.guild_id, self.botId);
                     const permissions = this.checkPermissions(appPermissions, command.botPermissions);
-                    if (!appPermissions.has('Administrator') && permissions) {
+                    if (permissions) {
                         return command.onBotPermissionsFail?.(context, permissions);
                     }
                 }
@@ -311,7 +319,9 @@ class HandleCommand {
             try {
                 await command.onInternalError?.(this.client, command, error);
             }
-            catch { }
+            catch {
+                // http 418
+            }
         }
     }
     argsParser(content, _command, _message) {
@@ -387,34 +397,36 @@ class HandleCommand {
         });
     }
     checkPermissions(app, bot) {
+        if (app.has('Administrator'))
+            return;
         const permissions = app.missings(...app.values([bot]));
-        if (!app.has('Administrator') && permissions.length) {
+        if (permissions.length) {
             return app.keys(permissions);
         }
         return;
     }
-    async fetchChannel(_option, query) {
+    fetchChannel(_option, query) {
         const id = query.match(/[0-9]{17,19}/g)?.[0];
         if (id)
             return this.client.channels.raw(id);
         return null;
     }
-    async fetchUser(_option, query) {
+    fetchUser(_option, query) {
         const id = query.match(/[0-9]{17,19}/g)?.[0];
         if (id)
             return this.client.users.raw(id);
         return null;
     }
-    async fetchMember(_option, query, guildId) {
+    fetchMember(_option, query, guildId) {
         const id = query.match(/[0-9]{17,19}/g)?.[0];
         if (id)
             return this.client.members.raw(guildId, id);
         return null;
     }
-    async fetchRole(_option, query, guildId) {
+    fetchRole(_option, query, guildId) {
         const id = query.match(/[0-9]{17,19}/g)?.[0];
         if (id && guildId)
-            return (await this.client.roles.listRaw(guildId)).find(x => x.id === id);
+            return this.client.roles.raw(guildId, id);
         return null;
     }
     async runGlobalMiddlewares(command, context) {
@@ -433,7 +445,9 @@ class HandleCommand {
             try {
                 await command.onInternalError?.(this.client, command, e);
             }
-            catch { }
+            catch {
+                // http 418
+            }
         }
         return false;
     }
@@ -453,7 +467,9 @@ class HandleCommand {
             try {
                 await command.onInternalError?.(this.client, command, e);
             }
-            catch { }
+            catch {
+                // http 418
+            }
         }
         return false;
     }
@@ -478,7 +494,9 @@ class HandleCommand {
                 try {
                     await command.onInternalError?.(this.client, command, e);
                 }
-                catch { }
+                catch {
+                    // http 418
+                }
             }
             return false;
         }
@@ -513,13 +531,14 @@ class HandleCommand {
                             if (channel) {
                                 if ('channel_types' in i) {
                                     if (!i.channel_types.includes(channel.type)) {
-                                        errors.push({
-                                            name: i.name,
-                                            error: `The entered channel type is not one of ${i
-                                                .channel_types.map(t => types_1.ChannelType[t])
-                                                .join(', ')}`,
-                                            fullError: ['CHANNEL_TYPES', i.channel_types],
-                                        });
+                                        if (i.required)
+                                            errors.push({
+                                                name: i.name,
+                                                error: `The entered channel type is not one of ${i
+                                                    .channel_types.map(t => types_1.ChannelType[t])
+                                                    .join(', ')}`,
+                                                fullError: ['CHANNEL_TYPES', i.channel_types],
+                                            });
                                         break;
                                     }
                                 }
@@ -601,22 +620,24 @@ class HandleCommand {
                             if (option.min_length) {
                                 if (value.length < option.min_length) {
                                     value = undefined;
-                                    errors.push({
-                                        name: i.name,
-                                        error: `The entered string has less than ${option.min_length} characters. The minimum required is ${option.min_length} characters.`,
-                                        fullError: ['STRING_MIN_LENGTH', option.min_length],
-                                    });
+                                    if (i.required)
+                                        errors.push({
+                                            name: i.name,
+                                            error: `The entered string has less than ${option.min_length} characters. The minimum required is ${option.min_length} characters.`,
+                                            fullError: ['STRING_MIN_LENGTH', option.min_length],
+                                        });
                                     break;
                                 }
                             }
                             if (option.max_length) {
                                 if (value.length > option.max_length) {
                                     value = undefined;
-                                    errors.push({
-                                        name: i.name,
-                                        error: `The entered string has more than ${option.max_length} characters. The maximum required is ${option.max_length} characters.`,
-                                        fullError: ['STRING_MAX_LENGTH', option.max_length],
-                                    });
+                                    if (i.required)
+                                        errors.push({
+                                            name: i.name,
+                                            error: `The entered string has more than ${option.max_length} characters. The maximum required is ${option.max_length} characters.`,
+                                            fullError: ['STRING_MAX_LENGTH', option.max_length],
+                                        });
                                     break;
                                 }
                             }
@@ -624,13 +645,14 @@ class HandleCommand {
                                 const choice = option.choices.find(x => x.name === value);
                                 if (!choice) {
                                     value = undefined;
-                                    errors.push({
-                                        name: i.name,
-                                        error: `The entered choice is invalid. Please choose one of the following options: ${option.choices
-                                            .map(x => x.name)
-                                            .join(', ')}.`,
-                                        fullError: ['STRING_INVALID_CHOICE', option.choices],
-                                    });
+                                    if (i.required)
+                                        errors.push({
+                                            name: i.name,
+                                            error: `The entered choice is invalid. Please choose one of the following options: ${option.choices
+                                                .map(x => x.name)
+                                                .join(', ')}.`,
+                                            fullError: ['STRING_INVALID_CHOICE', option.choices],
+                                        });
                                     break;
                                 }
                                 value = choice.value;
@@ -649,32 +671,35 @@ class HandleCommand {
                                 }
                                 if (Number.isNaN(value)) {
                                     value = undefined;
-                                    errors.push({
-                                        name: i.name,
-                                        error: 'The entered choice is an invalid number.',
-                                        fullError: ['NUMBER_NAN', args[i.name]],
-                                    });
+                                    if (i.required)
+                                        errors.push({
+                                            name: i.name,
+                                            error: 'The entered choice is an invalid number.',
+                                            fullError: ['NUMBER_NAN', args[i.name]],
+                                        });
                                     break;
                                 }
                                 if (option.min_value) {
                                     if (value < option.min_value) {
                                         value = undefined;
-                                        errors.push({
-                                            name: i.name,
-                                            error: `The entered number is less than ${option.min_value}. The minimum allowed is ${option.min_value}`,
-                                            fullError: ['NUMBER_MIN_VALUE', option.min_value],
-                                        });
+                                        if (i.required)
+                                            errors.push({
+                                                name: i.name,
+                                                error: `The entered number is less than ${option.min_value}. The minimum allowed is ${option.min_value}`,
+                                                fullError: ['NUMBER_MIN_VALUE', option.min_value],
+                                            });
                                         break;
                                     }
                                 }
                                 if (option.max_value) {
                                     if (value > option.max_value) {
                                         value = undefined;
-                                        errors.push({
-                                            name: i.name,
-                                            error: `The entered number is greater than ${option.max_value}. The maximum allowed is ${option.max_value}`,
-                                            fullError: ['NUMBER_MAX_VALUE', option.max_value],
-                                        });
+                                        if (i.required)
+                                            errors.push({
+                                                name: i.name,
+                                                error: `The entered number is greater than ${option.max_value}. The maximum allowed is ${option.max_value}`,
+                                                fullError: ['NUMBER_MAX_VALUE', option.max_value],
+                                            });
                                         break;
                                     }
                                 }
@@ -683,13 +708,14 @@ class HandleCommand {
                             const choice = option.choices.find(x => x.name === args[i.name]);
                             if (!choice) {
                                 value = undefined;
-                                errors.push({
-                                    name: i.name,
-                                    error: `The entered choice is invalid. Please choose one of the following options: ${option.choices
-                                        .map(x => x.name)
-                                        .join(', ')}.`,
-                                    fullError: ['NUMBER_INVALID_CHOICE', option.choices],
-                                });
+                                if (i.required)
+                                    errors.push({
+                                        name: i.name,
+                                        error: `The entered choice is invalid. Please choose one of the following options: ${option.choices
+                                            .map(x => x.name)
+                                            .join(', ')}.`,
+                                        fullError: ['NUMBER_INVALID_CHOICE', option.choices],
+                                    });
                                 break;
                             }
                             value = choice.value;

package/lib/commands/handler.d.ts

@@ -1,25 +1,25 @@
-import { type APIApplicationCommandOption, type LocalizationMap } from '../types';
+import type { EntryPointCommand } from '.';
 import type { Logger, MakeRequired, NulleableCoalising, OmitInsert } from '../common';
 import { BaseHandler } from '../common';
+import { type APIApplicationCommandOption, type LocalizationMap } from '../types';
 import { Command, type CommandOption, SubCommand } from './applications/chat';
 import { ContextMenuCommand } from './applications/menu';
 import type { UsingClient } from './applications/shared';
-import type { EntryPointCommand } from '.';
 export declare class CommandHandler extends BaseHandler {
     protected logger: Logger;
     protected client: UsingClient;
     values: (Command | ContextMenuCommand)[];
     entryPoint: EntryPointCommand | null;
-    protected filter: (path: string) => boolean;
+    filter: (path: string) => boolean;
     constructor(logger: Logger, client: UsingClient);
     reload(resolve: string | Command): Promise<void>;
     reloadAll(stopIfFail?: boolean): Promise<void>;
     protected shouldUploadLocales(locales?: LocalizationMap | null, cachedLocales?: LocalizationMap | null): boolean;
-    protected shouldUploadOption(option: APIApplicationCommandOption, cached: APIApplicationCommandOption): boolean | undefined;
+    protected shouldUploadOption(option: APIApplicationCommandOption, cached: APIApplicationCommandOption): boolean;
     shouldUpload(file: string, guildId?: string): Promise<boolean>;
     set(commands: SeteableCommand[]): void;
     load(commandsDir: string, client: UsingClient): Promise<(Command | ContextMenuCommand)[]>;
-    parseLocales(command: InstanceType<HandleableCommand>): Command | ContextMenuCommand | EntryPointCommand | SubCommand;
+    parseLocales(command: InstanceType<HandleableCommand>): Command | ContextMenuCommand | SubCommand | EntryPointCommand;
     parseGlobalLocales(command: InstanceType<HandleableCommand>): void;
     parseCommandOptionLocales(option: MakeRequired<CommandOption, 'locales'>): void;
     parseCommandLocales(command: Command): void;

package/lib/commands/handler.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandHandler = void 0;
-const types_1 = require("../types");
+const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const common_1 = require("../common");
+const Permissions_1 = require("../structures/extra/Permissions");
+const types_1 = require("../types");
 const chat_1 = require("./applications/chat");
 const menu_1 = require("./applications/menu");
-const node_fs_1 = require("node:fs");
 class CommandHandler extends common_1.BaseHandler {
     logger;
     client;
@@ -89,22 +90,25 @@ class CommandHandler extends common_1.BaseHandler {
                         return option.channel_types.some(ct => !cached.channel_types.includes(ct));
                     }
                 }
-                return;
+                break;
             case types_1.ApplicationCommandOptionType.Subcommand:
             case types_1.ApplicationCommandOptionType.SubcommandGroup:
-                if (option.options?.length !==
-                    cached.options?.length) {
-                    return true;
-                }
-                if (option.options &&
-                    cached.options)
-                    for (const i of option.options) {
-                        const cachedOption = cached.options.find(x => x.name === i.name);
-                        if (!cachedOption)
-                            return true;
-                        if (this.shouldUploadOption(i, cachedOption))
-                            return true;
+                {
+                    if (option.options?.length !==
+                        cached.options
+                            ?.length) {
+                        return true;
                     }
+                    if (option.options &&
+                        cached.options)
+                        for (const i of option.options) {
+                            const cachedOption = cached.options.find(x => x.name === i.name);
+                            if (!cachedOption)
+                                return true;
+                            if (this.shouldUploadOption(i, cachedOption))
+                                return true;
+                        }
+                }
                 break;
             case types_1.ApplicationCommandOptionType.Integer:
             case types_1.ApplicationCommandOptionType.Number:
@@ -470,8 +474,8 @@ class CommandHandler extends common_1.BaseHandler {
             option.onPermissionsFail?.bind(option) ??
                 commandInstance.onPermissionsFail?.bind(commandInstance) ??
                 this.client.options.commands?.defaults?.onPermissionsFail;
-        option.botPermissions ??= commandInstance.botPermissions;
-        option.defaultMemberPermissions ??= commandInstance.defaultMemberPermissions;
+        option.botPermissions = new Permissions_1.PermissionsBitField().add(option.botPermissions ?? Permissions_1.PermissionsBitField.None, commandInstance.botPermissions);
+        option.defaultMemberPermissions ??= new Permissions_1.PermissionsBitField().add(option.defaultMemberPermissions ?? Permissions_1.PermissionsBitField.None, commandInstance.defaultMemberPermissions);
         option.contexts ??= commandInstance.contexts;
         option.integrationTypes ??= commandInstance.integrationTypes;
         option.props ??= commandInstance.props;