seyfert 1.4.0 → 2.0.0

package/lib/commands/handler.d.ts

@@ -1,7 +1,7 @@
-import { type APIApplicationCommandOption } from 'discord-api-types/v10';
-import type { Logger } from '../common';
+import { type APIApplicationCommandOption, type LocalizationMap } from '../types';
+import type { Logger, MakeRequired, NulleableCoalising, OmitInsert } from '../common';
 import { BaseHandler } from '../common';
-import { Command, SubCommand } from './applications/chat';
+import { Command, type CommandOption, SubCommand } from './applications/chat';
 import { ContextMenuCommand } from './applications/menu';
 import type { UsingClient } from './applications/shared';
 export declare class CommandHandler extends BaseHandler {
@@ -12,20 +12,29 @@ export declare class CommandHandler extends BaseHandler {
     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;
-    shouldUpload(file: string): Promise<boolean>;
-    load(commandsDir: string, client: UsingClient, instances?: {
-        new (): Command | ContextMenuCommand;
-    }[]): Promise<(Command | ContextMenuCommand)[]>;
-    private __parseCommandLocales;
-    setHandlers({ onCommand, onSubCommand, }: {
-        onCommand?: CommandHandler['onCommand'];
-        onSubCommand?: CommandHandler['onSubCommand'];
-    }): void;
-    onCommand: (file: {
-        new (): Command | SubCommand | ContextMenuCommand;
-    }) => Command | SubCommand | ContextMenuCommand | false;
-    onSubCommand: (file: {
-        new (): SubCommand;
-    }) => SubCommand | false;
+    shouldUpload(file: string, guildId?: string): Promise<boolean>;
+    set(commands: SeteableCommand[]): void;
+    load(commandsDir: string, client: UsingClient): Promise<(Command | ContextMenuCommand)[]>;
+    parseLocales(command: Command | SubCommand | ContextMenuCommand): Command | ContextMenuCommand | SubCommand;
+    parseGlobalLocales(command: Command | SubCommand | ContextMenuCommand): void;
+    parseCommandOptionLocales(option: MakeRequired<CommandOption, 'locales'>): void;
+    parseCommandLocales(command: Command): void;
+    parseContextMenuLocales(command: ContextMenuCommand): ContextMenuCommand;
+    parseSubCommandLocales(command: SubCommand): SubCommand;
+    stablishContextCommandDefaults(commandInstance: InstanceType<HandleableCommand>): ContextMenuCommand | false;
+    stablishCommandDefaults(commandInstance: InstanceType<HandleableCommand>): OmitInsert<Command, 'options', {
+        options: NonNullable<Command['options']>;
+    }> | false;
+    stablishSubCommandDefaults(commandInstance: Command, option: SubCommand): SubCommand;
+    onFile(file: FileLoaded): HandleableCommand[] | undefined;
+    onCommand(file: HandleableCommand): Command | SubCommand | ContextMenuCommand | false;
+    onSubCommand(file: HandleableSubCommand): SubCommand | false;
 }
+export type FileLoaded<T = null> = {
+    default?: NulleableCoalising<T, HandleableCommand>;
+} & Record<string, NulleableCoalising<T, HandleableCommand>>;
+export type HandleableCommand = new () => Command | SubCommand | ContextMenuCommand;
+export type SeteableCommand = new () => Extract<InstanceType<HandleableCommand>, SubCommand>;
+export type HandleableSubCommand = new () => SubCommand;

package/lib/commands/handler.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandHandler = void 0;
-const v10_1 = require("discord-api-types/v10");
+const types_1 = require("../types");
 const node_path_1 = require("node:path");
 const common_1 = require("../common");
 const chat_1 = require("./applications/chat");
@@ -18,6 +18,9 @@ class CommandHandler extends common_1.BaseHandler {
         this.client = client;
     }
     async reload(resolve) {
+        if ((0, common_1.isCloudfareWorker)()) {
+            throw new Error('Reload in cloudfare worker is not supported');
+        }
         if (typeof resolve === 'string') {
             return this.values.find(x => x.name === resolve)?.reload();
         }
@@ -35,6 +38,28 @@ class CommandHandler extends common_1.BaseHandler {
             }
         }
     }
+    shouldUploadLocales(locales, cachedLocales) {
+        if (!(locales || cachedLocales))
+            return false;
+        if (!locales && cachedLocales)
+            return true;
+        if (locales && !cachedLocales)
+            return true;
+        if (locales && cachedLocales) {
+            const localesEntries = Object.entries(locales);
+            const cachedLocalesEntries = Object.entries(cachedLocales);
+            if (localesEntries.length !== cachedLocalesEntries.length)
+                return true;
+            for (const [key, value] of localesEntries) {
+                const cached = cachedLocalesEntries.find(x => x[0] === key);
+                if (!cached)
+                    return true;
+                if (value !== cached[1])
+                    return true;
+            }
+        }
+        return false;
+    }
     shouldUploadOption(option, cached) {
         if (option.description !== cached.description)
             return true;
@@ -45,23 +70,27 @@ class CommandHandler extends common_1.BaseHandler {
         if (option.name !== cached.name)
             return true;
         //TODO: locales
+        if (this.shouldUploadLocales(option.name_localizations, cached.name_localizations))
+            return true;
+        if (this.shouldUploadLocales(option.description_localizations, cached.description_localizations))
+            return true;
         switch (option.type) {
-            case v10_1.ApplicationCommandOptionType.String:
+            case types_1.ApplicationCommandOptionType.String:
                 return (option.min_length !== cached.min_length ||
                     option.max_length !== cached.max_length);
-            case v10_1.ApplicationCommandOptionType.Channel:
+            case types_1.ApplicationCommandOptionType.Channel:
                 {
                     if (option.channel_types?.length !== cached.channel_types?.length)
                         return true;
                     if ('channel_types' in option && 'channel_types' in cached) {
-                        if (!option.channel_types || !cached.channel_types)
+                        if (!(option.channel_types && cached.channel_types))
                             return true;
                         return option.channel_types.some(ct => !cached.channel_types.includes(ct));
                     }
                 }
                 return;
-            case v10_1.ApplicationCommandOptionType.Subcommand:
-            case v10_1.ApplicationCommandOptionType.SubcommandGroup:
+            case types_1.ApplicationCommandOptionType.Subcommand:
+            case types_1.ApplicationCommandOptionType.SubcommandGroup:
                 if (option.options?.length !==
                     cached.options?.length) {
                     return true;
@@ -76,28 +105,37 @@ class CommandHandler extends common_1.BaseHandler {
                             return true;
                     }
                 break;
-            case v10_1.ApplicationCommandOptionType.Integer:
-            case v10_1.ApplicationCommandOptionType.Number:
+            case types_1.ApplicationCommandOptionType.Integer:
+            case types_1.ApplicationCommandOptionType.Number:
                 return (option.min_value !== cached.min_value ||
                     option.max_value !== cached.max_value);
-            case v10_1.ApplicationCommandOptionType.Attachment:
-            case v10_1.ApplicationCommandOptionType.Boolean:
-            case v10_1.ApplicationCommandOptionType.Mentionable:
-            case v10_1.ApplicationCommandOptionType.Role:
-            case v10_1.ApplicationCommandOptionType.User:
+            case types_1.ApplicationCommandOptionType.Attachment:
+            case types_1.ApplicationCommandOptionType.Boolean:
+            case types_1.ApplicationCommandOptionType.Mentionable:
+            case types_1.ApplicationCommandOptionType.Role:
+            case types_1.ApplicationCommandOptionType.User:
                 break;
         }
         return false;
     }
-    async shouldUpload(file) {
+    async shouldUpload(file, guildId) {
+        const values = this.values.filter(x => {
+            if (!guildId)
+                return !x.guildId;
+            return x.guildId?.includes(guildId);
+        });
         if (!(await node_fs_1.promises.access(file).then(() => true, () => false))) {
-            await node_fs_1.promises.writeFile(file, JSON.stringify(this.values.map(x => x.toJSON())));
+            await node_fs_1.promises.writeFile(file, JSON.stringify(values.map(x => x.toJSON())));
             return true;
         }
-        const cachedCommands = JSON.parse((await node_fs_1.promises.readFile(file)).toString());
-        if (cachedCommands.length !== this.values.length)
+        const cachedCommands = JSON.parse((await node_fs_1.promises.readFile(file)).toString()).filter(x => {
+            if (!guildId)
+                return !x.guild_id;
+            return x.guild_id?.includes(guildId);
+        });
+        if (cachedCommands.length !== values.length)
             return true;
-        for (const command of this.values.map(x => x.toJSON())) {
+        for (const command of values.map(x => x.toJSON())) {
             const cached = cachedCommands.find(x => {
                 if (x.name !== command.name)
                     return false;
@@ -121,9 +159,12 @@ class CommandHandler extends common_1.BaseHandler {
                 return true;
             if (!!cached.integration_types !== !!command.integration_types)
                 return true;
-            //TODO: locales
+            if (this.shouldUploadLocales(command.name_localizations, cached.name_localizations))
+                return true;
+            if (this.shouldUploadLocales(command.description_localizations, cached.description_localizations))
+                return true;
             if ('contexts' in command && 'contexts' in cached) {
-                if (command.contexts?.length !== cached.contexts?.length)
+                if (command.contexts.length !== cached.contexts.length)
                     return true;
                 if (command.contexts && cached.contexts) {
                     if (command.contexts.some(ctx => !cached.contexts.includes(ctx)))
@@ -131,7 +172,7 @@ class CommandHandler extends common_1.BaseHandler {
                 }
             }
             if ('integration_types' in command && 'integration_types' in cached) {
-                if (command.integration_types?.length !== cached.integration_types?.length)
+                if (command.integration_types.length !== cached.integration_types.length)
                     return true;
                 if (command.integration_types && cached.integration_types) {
                     if (command.integration_types.some(ctx => !cached.integration_types.includes(ctx)))
@@ -152,198 +193,293 @@ class CommandHandler extends common_1.BaseHandler {
         }
         return false;
     }
-    async load(commandsDir, client, instances) {
-        const result = instances?.map(x => {
-            const i = new x();
-            return { name: i.name, file: x, path: i.__filePath ?? '*' };
-        }) ??
-            (await this.loadFilesK(await this.getFiles(commandsDir))).filter(x => x.file);
-        this.values = [];
-        for (const command of result) {
+    set(commands) {
+        this.values ??= [];
+        for (const command of commands) {
             let commandInstance;
             try {
-                commandInstance = this.onCommand(command.file);
+                commandInstance = this.onCommand(command);
                 if (!commandInstance)
                     continue;
             }
             catch (e) {
-                if (e instanceof Error && e.message.includes('is not a constructor')) {
-                    this.logger.warn(`${command.path
-                        .split(process.cwd())
-                        .slice(1)
-                        .join(process.cwd())} doesn't export the class by \`export default <Command>\``);
-                }
-                else
-                    this.logger.warn(e, command);
+                this.logger.warn(`${command.name} ins't a resolvable command`);
+                this.logger.error(e);
                 continue;
             }
-            if (commandInstance instanceof menu_1.ContextMenuCommand) {
-                this.values.push(commandInstance);
-                commandInstance.__filePath = command.path;
-                continue;
+            commandInstance.props = this.client.options.commands?.defaults?.props ?? {};
+            const isCommand = this.stablishCommandDefaults(commandInstance);
+            if (isCommand) {
+                for (const option of commandInstance.options ?? []) {
+                    if (option instanceof chat_1.SubCommand)
+                        this.stablishSubCommandDefaults(commandInstance, option);
+                }
             }
-            if (!(commandInstance instanceof chat_1.Command)) {
+            else
+                this.stablishContextCommandDefaults(commandInstance);
+            this.parseLocales(commandInstance);
+            this.values.push(commandInstance);
+        }
+    }
+    async load(commandsDir, client) {
+        const result = await this.loadFilesK(await this.getFiles(commandsDir));
+        this.values = [];
+        for (const { commands, file } of result.map(x => ({ commands: this.onFile(x.file), file: x }))) {
+            if (!commands)
                 continue;
-            }
-            commandInstance.onAfterRun ??= client.options?.commands?.defaults?.onAfterRun;
-            commandInstance.onBotPermissionsFail ??= client.options?.commands?.defaults?.onBotPermissionsFail;
-            commandInstance.onInternalError ??= client.options?.commands?.defaults?.onInternalError;
-            commandInstance.onMiddlewaresError ??= client.options?.commands?.defaults?.onMiddlewaresError;
-            commandInstance.onOptionsError ??= client.options?.commands?.defaults?.onOptionsError;
-            commandInstance.onPermissionsFail ??= client.options?.commands?.defaults?.onPermissionsFail;
-            commandInstance.onRunError ??= client.options?.commands?.defaults?.onRunError;
-            commandInstance.__filePath = command.path;
-            commandInstance.options ??= [];
-            if (commandInstance.__autoload) {
-                //@AutoLoad
-                const options = await this.getFiles((0, node_path_1.dirname)(command.path));
-                for (const option of options) {
-                    if (command.name === (0, node_path_1.basename)(option)) {
+            for (const command of commands) {
+                let commandInstance;
+                try {
+                    commandInstance = this.onCommand(command);
+                    if (!commandInstance)
                         continue;
+                }
+                catch (e) {
+                    if (e instanceof Error && e.message.includes('is not a constructor')) {
+                        this.logger.warn(`${file.path
+                            .split(process.cwd())
+                            .slice(1)
+                            .join(process.cwd())} doesn't export the class by \`export default <Command>\``);
                     }
-                    try {
-                        const subCommand = this.onSubCommand(result.find(x => x.path === option).file);
-                        if (subCommand && subCommand instanceof chat_1.SubCommand) {
-                            subCommand.__filePath = option;
-                            commandInstance.options.push(subCommand);
+                    else
+                        this.logger.warn(e, command);
+                    continue;
+                }
+                if (commandInstance instanceof chat_1.SubCommand)
+                    continue;
+                commandInstance.__filePath = file.path;
+                commandInstance.props ??= client.options.commands?.defaults?.props ?? {};
+                const isAvailableCommand = this.stablishCommandDefaults(commandInstance);
+                if (isAvailableCommand) {
+                    commandInstance = isAvailableCommand;
+                    if (commandInstance.__autoload) {
+                        //@AutoLoad
+                        const options = await this.getFiles((0, node_path_1.dirname)(file.path));
+                        for (const option of options) {
+                            if (file.name === (0, node_path_1.basename)(option)) {
+                                continue;
+                            }
+                            try {
+                                const fileSubCommands = this.onFile(result.find(x => x.path === option).file);
+                                if (!fileSubCommands) {
+                                    this.logger.warn(`SubCommand returned (${fileSubCommands}) ignoring.`);
+                                    continue;
+                                }
+                                for (const fileSubCommand of fileSubCommands) {
+                                    const subCommand = this.onSubCommand(fileSubCommand);
+                                    if (subCommand && subCommand instanceof chat_1.SubCommand) {
+                                        subCommand.__filePath = option;
+                                        commandInstance.options.push(subCommand);
+                                    }
+                                    else {
+                                        this.logger.warn(subCommand ? 'SubCommand expected' : 'Invalid SubCommand', subCommand);
+                                    }
+                                }
+                            }
+                            catch {
+                                //pass
+                            }
                         }
                     }
-                    catch {
-                        //pass
+                    for (const option of commandInstance.options ?? []) {
+                        if (option instanceof chat_1.SubCommand)
+                            this.stablishSubCommandDefaults(commandInstance, option);
                     }
                 }
+                this.stablishContextCommandDefaults(commandInstance);
+                this.values.push(commandInstance);
+                this.parseLocales(commandInstance);
             }
-            for (const option of commandInstance.options ?? []) {
+        }
+        return this.values;
+    }
+    parseLocales(command) {
+        this.parseGlobalLocales(command);
+        if (command instanceof menu_1.ContextMenuCommand) {
+            this.parseContextMenuLocales(command);
+            return command;
+        }
+        if (command instanceof chat_1.Command && command.__tGroups) {
+            this.parseCommandLocales(command);
+            for (const option of command.options ?? []) {
                 if (option instanceof chat_1.SubCommand) {
-                    option.middlewares = (commandInstance.middlewares ?? []).concat(option.middlewares ?? []);
-                    option.onMiddlewaresError =
-                        option.onMiddlewaresError?.bind(option) ??
-                            commandInstance.onMiddlewaresError?.bind(commandInstance) ??
-                            this.client.options?.commands?.defaults?.onMiddlewaresError;
-                    option.onRunError =
-                        option.onRunError?.bind(option) ??
-                            commandInstance.onRunError?.bind(commandInstance) ??
-                            this.client.options?.commands?.defaults?.onRunError;
-                    option.onOptionsError =
-                        option.onOptionsError?.bind(option) ??
-                            commandInstance.onOptionsError?.bind(commandInstance) ??
-                            this.client.options?.commands?.defaults?.onOptionsError;
-                    option.onInternalError =
-                        option.onInternalError?.bind(option) ??
-                            commandInstance.onInternalError?.bind(commandInstance) ??
-                            this.client.options?.commands?.defaults?.onInternalError;
-                    option.onAfterRun =
-                        option.onAfterRun?.bind(option) ??
-                            commandInstance.onAfterRun?.bind(commandInstance) ??
-                            this.client.options?.commands?.defaults?.onAfterRun;
-                    option.onBotPermissionsFail =
-                        option.onBotPermissionsFail?.bind(option) ??
-                            commandInstance.onBotPermissionsFail?.bind(commandInstance) ??
-                            this.client.options?.commands?.defaults?.onBotPermissionsFail;
-                    option.onPermissionsFail =
-                        option.onPermissionsFail?.bind(option) ??
-                            commandInstance.onPermissionsFail?.bind(commandInstance) ??
-                            this.client.options?.commands?.defaults?.onPermissionsFail;
-                }
-            }
-            this.values.push(commandInstance);
-            this.__parseCommandLocales(commandInstance, client);
-            for (const i of commandInstance.options ?? []) {
-                if (i instanceof chat_1.SubCommand) {
-                    this.__parseCommandLocales(i, client);
+                    this.parseSubCommandLocales(option);
+                    continue;
                 }
+                // @ts-expect-error
+                if (option.locales)
+                    this.parseCommandOptionLocales(option);
             }
         }
-        return this.values;
+        if (command instanceof chat_1.SubCommand) {
+            this.parseSubCommandLocales(command);
+        }
+        return command;
     }
-    __parseCommandLocales(command, client) {
+    parseGlobalLocales(command) {
         if (command.__t) {
             command.name_localizations = {};
             command.description_localizations = {};
-            for (const locale of Object.keys(client.langs.values)) {
+            for (const locale of Object.keys(this.client.langs.values)) {
                 const locales = this.client.langs.aliases.find(x => x[0] === locale)?.[1] ?? [];
-                if (Object.values(v10_1.Locale).includes(locale))
+                if (Object.values(types_1.Locale).includes(locale))
                     locales.push(locale);
                 if (command.__t.name) {
                     for (const i of locales) {
-                        const valueName = client.langs.getKey(locale, command.__t.name);
+                        const valueName = this.client.langs.getKey(locale, command.__t.name);
                         if (valueName)
                             command.name_localizations[i] = valueName;
                     }
                 }
                 if (command.__t.description) {
                     for (const i of locales) {
-                        const valueKey = client.langs.getKey(locale, command.__t.description);
+                        const valueKey = this.client.langs.getKey(locale, command.__t.description);
                         if (valueKey)
                             command.description_localizations[i] = valueKey;
                     }
                 }
             }
         }
-        for (const options of command.options ?? []) {
-            if (options instanceof chat_1.SubCommand || !options.locales)
-                continue;
-            options.name_localizations = {};
-            options.description_localizations = {};
-            for (const locale of Object.keys(client.langs.values)) {
-                const locales = this.client.langs.aliases.find(x => x[0] === locale)?.[1] ?? [];
-                if (Object.values(v10_1.Locale).includes(locale))
-                    locales.push(locale);
-                if (options.locales.name) {
-                    for (const i of locales) {
-                        const valueName = client.langs.getKey(locale, options.locales.name);
-                        if (valueName)
-                            options.name_localizations[i] = valueName;
-                    }
+    }
+    parseCommandOptionLocales(option) {
+        option.name_localizations = {};
+        option.description_localizations = {};
+        for (const locale of Object.keys(this.client.langs.values)) {
+            const locales = this.client.langs.aliases.find(x => x[0] === locale)?.[1] ?? [];
+            if (Object.values(types_1.Locale).includes(locale))
+                locales.push(locale);
+            if (option.locales.name) {
+                for (const i of locales) {
+                    const valueName = this.client.langs.getKey(locale, option.locales.name);
+                    if (valueName)
+                        option.name_localizations[i] = valueName;
                 }
-                if (options.locales.description) {
-                    for (const i of locales) {
-                        const valueKey = client.langs.getKey(locale, options.locales.description);
-                        if (valueKey)
-                            options.description_localizations[i] = valueKey;
-                    }
+            }
+            if (option.locales.description) {
+                for (const i of locales) {
+                    const valueKey = this.client.langs.getKey(locale, option.locales.description);
+                    if (valueKey)
+                        option.description_localizations[i] = valueKey;
                 }
             }
         }
-        if (command instanceof chat_1.Command && command.__tGroups) {
-            command.groups = {};
-            for (const locale of Object.keys(client.langs.values)) {
-                const locales = this.client.langs.aliases.find(x => x[0] === locale)?.[1] ?? [];
-                if (Object.values(v10_1.Locale).includes(locale))
-                    locales.push(locale);
-                for (const group in command.__tGroups) {
-                    command.groups[group] ??= {
-                        defaultDescription: command.__tGroups[group].defaultDescription,
-                        description: [],
-                        name: [],
-                    };
-                    if (command.__tGroups[group].name) {
-                        for (const i of locales) {
-                            const valueName = client.langs.getKey(locale, command.__tGroups[group].name);
-                            if (valueName) {
-                                command.groups[group].name.push([i, valueName]);
-                            }
+    }
+    parseCommandLocales(command) {
+        command.groups = {};
+        for (const locale of Object.keys(this.client.langs.values)) {
+            const locales = this.client.langs.aliases.find(x => x[0] === locale)?.[1] ?? [];
+            if (Object.values(types_1.Locale).includes(locale))
+                locales.push(locale);
+            for (const group in command.__tGroups) {
+                command.groups[group] ??= {
+                    defaultDescription: command.__tGroups[group].defaultDescription,
+                    description: [],
+                    name: [],
+                };
+                if (command.__tGroups[group].name) {
+                    for (const i of locales) {
+                        const valueName = this.client.langs.getKey(locale, command.__tGroups[group].name);
+                        if (valueName) {
+                            command.groups[group].name.push([i, valueName]);
                         }
                     }
-                    if (command.__tGroups[group].description) {
-                        for (const i of locales) {
-                            const valueKey = client.langs.getKey(locale, command.__tGroups[group].description);
-                            if (valueKey) {
-                                command.groups[group].description.push([i, valueKey]);
-                            }
+                }
+                if (command.__tGroups[group].description) {
+                    for (const i of locales) {
+                        const valueKey = this.client.langs.getKey(locale, command.__tGroups[group].description);
+                        if (valueKey) {
+                            command.groups[group].description.push([i, valueKey]);
                         }
                     }
                 }
             }
         }
     }
-    setHandlers({ onCommand, onSubCommand, }) {
-        if (onCommand)
-            this.onCommand = onCommand;
-        if (onSubCommand)
-            this.onSubCommand = onSubCommand;
+    parseContextMenuLocales(command) {
+        return command;
+    }
+    parseSubCommandLocales(command) {
+        for (const i of command.options ?? []) {
+            // @ts-expect-error
+            if (i.locales)
+                this.parseCommandOptionLocales(i);
+        }
+        return command;
+    }
+    stablishContextCommandDefaults(commandInstance) {
+        if (!(commandInstance instanceof menu_1.ContextMenuCommand))
+            return false;
+        commandInstance.onAfterRun ??= this.client.options.commands?.defaults?.onAfterRun;
+        //@ts-expect-error magic.
+        commandInstance.onBotPermissionsFail ??= this.client.options.commands?.defaults?.onBotPermissionsFail;
+        //@ts-expect-error magic.
+        commandInstance.onInternalError ??= this.client.options.commands?.defaults?.onInternalError;
+        //@ts-expect-error magic.
+        commandInstance.onMiddlewaresError ??= this.client.options.commands?.defaults?.onMiddlewaresError;
+        //@ts-expect-error magic.
+        commandInstance.onPermissionsFail ??= this.client.options.commands?.defaults?.onPermissionsFail;
+        //@ts-expect-error magic.
+        commandInstance.onRunError ??= this.client.options.commands?.defaults?.onRunError;
+        return commandInstance;
+    }
+    stablishCommandDefaults(commandInstance) {
+        if (!(commandInstance instanceof chat_1.Command))
+            return false;
+        commandInstance.onAfterRun ??= this.client.options.commands?.defaults?.onAfterRun;
+        commandInstance.onBotPermissionsFail ??= this.client.options.commands?.defaults?.onBotPermissionsFail;
+        commandInstance.onInternalError ??= this.client.options.commands?.defaults?.onInternalError;
+        commandInstance.onMiddlewaresError ??= this.client.options.commands?.defaults?.onMiddlewaresError;
+        commandInstance.onOptionsError ??= this.client.options.commands?.defaults?.onOptionsError;
+        commandInstance.onPermissionsFail ??= this.client.options.commands?.defaults?.onPermissionsFail;
+        commandInstance.onRunError ??= this.client.options.commands?.defaults?.onRunError;
+        commandInstance.options ??= [];
+        return commandInstance;
+    }
+    stablishSubCommandDefaults(commandInstance, option) {
+        option.middlewares = (commandInstance.middlewares ?? []).concat(option.middlewares ?? []);
+        option.onMiddlewaresError =
+            option.onMiddlewaresError?.bind(option) ??
+                commandInstance.onMiddlewaresError?.bind(commandInstance) ??
+                this.client.options.commands?.defaults?.onMiddlewaresError;
+        option.onRunError =
+            option.onRunError?.bind(option) ??
+                commandInstance.onRunError?.bind(commandInstance) ??
+                this.client.options.commands?.defaults?.onRunError;
+        option.onOptionsError =
+            option.onOptionsError?.bind(option) ??
+                commandInstance.onOptionsError?.bind(commandInstance) ??
+                this.client.options.commands?.defaults?.onOptionsError;
+        option.onInternalError =
+            option.onInternalError?.bind(option) ??
+                commandInstance.onInternalError?.bind(commandInstance) ??
+                this.client.options.commands?.defaults?.onInternalError;
+        option.onAfterRun =
+            option.onAfterRun?.bind(option) ??
+                commandInstance.onAfterRun?.bind(commandInstance) ??
+                this.client.options.commands?.defaults?.onAfterRun;
+        option.onBotPermissionsFail =
+            option.onBotPermissionsFail?.bind(option) ??
+                commandInstance.onBotPermissionsFail?.bind(commandInstance) ??
+                this.client.options.commands?.defaults?.onBotPermissionsFail;
+        option.onPermissionsFail =
+            option.onPermissionsFail?.bind(option) ??
+                commandInstance.onPermissionsFail?.bind(commandInstance) ??
+                this.client.options.commands?.defaults?.onPermissionsFail;
+        option.botPermissions ??= commandInstance.botPermissions;
+        option.defaultMemberPermissions ??= commandInstance.defaultMemberPermissions;
+        option.contexts ??= commandInstance.contexts;
+        option.integrationTypes ??= commandInstance.integrationTypes;
+        option.props ??= commandInstance.props;
+        return option;
+    }
+    onFile(file) {
+        return file.default ? [file.default] : undefined;
+    }
+    onCommand(file) {
+        return new file();
+    }
+    onSubCommand(file) {
+        return new file();
     }
-    onCommand = (file) => new file();
-    onSubCommand = (file) => new file();
 }
 exports.CommandHandler = CommandHandler;