@arox/framework 0.1.2-beta.1 → 0.1.3

package/dist/structures/builder/Builder.d.ts

@@ -1,19 +1,70 @@
-import { SlashCommandBuilder, RESTPostAPIChatInputApplicationCommandsJSONBody } from "discord.js";
-import { Client } from "../core";
+import { SlashCommandAttachmentOption, SlashCommandBooleanOption, SlashCommandBuilder, SlashCommandChannelOption, SlashCommandIntegerOption, SlashCommandMentionableOption, SlashCommandNumberOption, SlashCommandRoleOption, SlashCommandStringOption, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandUserOption, type RESTPostAPIChatInputApplicationCommandsJSONBody } from "discord.js";
+import { Client } from "../core/index.js";
 export interface ApplicationJSONBody extends RESTPostAPIChatInputApplicationCommandsJSONBody {
     prefix_support: boolean;
     slash_support: boolean;
-    aliases: string[];
+}
+export declare class AutoSlashCommandStringOption extends SlashCommandStringOption {
+    autoSet(key: string): this;
+}
+export declare class AutoSlashCommandIntegerOption extends SlashCommandIntegerOption {
+    autoSet(key: string): this;
+}
+export declare class AutoSlashCommandNumberOption extends SlashCommandNumberOption {
+    autoSet(key: string): this;
+}
+export declare class AutoSlashCommandBooleanOption extends SlashCommandBooleanOption {
+    autoSet(key: string): this;
+}
+export declare class AutoSlashCommandUserOption extends SlashCommandUserOption {
+    autoSet(key: string): this;
+}
+export declare class AutoSlashCommandChannelOption extends SlashCommandChannelOption {
+    autoSet(key: string): this;
+}
+export declare class AutoSlashCommandRoleOption extends SlashCommandRoleOption {
+    autoSet(key: string): this;
+}
+export declare class AutoSlashCommandMentionableOption extends SlashCommandMentionableOption {
+    autoSet(key: string): this;
+}
+export declare class AutoSlashCommandAttachmentOption extends SlashCommandAttachmentOption {
+    autoSet(key: string): this;
+}
+export declare class AutoSlashCommandSubcommandBuilder extends SlashCommandSubcommandBuilder {
+    autoSet(key: string): this;
+    addStringOption(input: SlashCommandStringOption | ((builder: SlashCommandStringOption) => SlashCommandStringOption)): SlashCommandSubcommandBuilder;
+    addIntegerOption(input: SlashCommandIntegerOption | ((builder: SlashCommandIntegerOption) => SlashCommandIntegerOption)): SlashCommandSubcommandBuilder;
+    addNumberOption(input: SlashCommandNumberOption | ((builder: SlashCommandNumberOption) => SlashCommandNumberOption)): SlashCommandSubcommandBuilder;
+    addBooleanOption(input: SlashCommandBooleanOption | ((builder: SlashCommandBooleanOption) => SlashCommandBooleanOption)): SlashCommandSubcommandBuilder;
+    addUserOption(input: SlashCommandUserOption | ((builder: SlashCommandUserOption) => SlashCommandUserOption)): SlashCommandSubcommandBuilder;
+    addChannelOption(input: SlashCommandChannelOption | ((builder: SlashCommandChannelOption) => SlashCommandChannelOption)): SlashCommandSubcommandBuilder;
+    addRoleOption(input: SlashCommandRoleOption | ((builder: SlashCommandRoleOption) => SlashCommandRoleOption)): SlashCommandSubcommandBuilder;
+    addMentionableOption(input: SlashCommandMentionableOption | ((builder: SlashCommandMentionableOption) => SlashCommandMentionableOption)): SlashCommandSubcommandBuilder;
+    addAttachmentOption(input: SlashCommandAttachmentOption | ((builder: SlashCommandAttachmentOption) => SlashCommandAttachmentOption)): SlashCommandSubcommandBuilder;
+}
+export declare class AutoSlashCommandSubcommandGroupBuilder extends SlashCommandSubcommandGroupBuilder {
+    autoSet(key: string): this;
+    addSubcommand(input: SlashCommandSubcommandBuilder | ((subcommandGroup: SlashCommandSubcommandBuilder) => SlashCommandSubcommandBuilder)): this;
 }
 export declare class ApplicationCommandBuilder extends SlashCommandBuilder {
-    constructor();
     protected prefix_support: boolean;
     protected slash_support: boolean;
-    protected aliases: string[];
-    setAliases(...alias: string[]): this;
-    addAliases(...alias: string[]): this;
-    setPrefixSupport(support: boolean): this;
-    setSlashSupport(support: boolean): this;
+    setPrefixSupport(value?: boolean): this;
+    setSlashSupport(value?: boolean): this;
+    autoSet(key: string): this;
+    addStringOption(input: SlashCommandStringOption | ((builder: SlashCommandStringOption) => SlashCommandStringOption)): import("discord.js").SlashCommandOptionsOnlyBuilder;
+    addIntegerOption(input: SlashCommandIntegerOption | ((builder: SlashCommandIntegerOption) => SlashCommandIntegerOption)): import("discord.js").SlashCommandOptionsOnlyBuilder;
+    addNumberOption(input: SlashCommandNumberOption | ((builder: SlashCommandNumberOption) => SlashCommandNumberOption)): import("discord.js").SlashCommandOptionsOnlyBuilder;
+    addBooleanOption(input: SlashCommandBooleanOption | ((builder: SlashCommandBooleanOption) => SlashCommandBooleanOption)): import("discord.js").SlashCommandOptionsOnlyBuilder;
+    addUserOption(input: SlashCommandUserOption | ((builder: SlashCommandUserOption) => SlashCommandUserOption)): import("discord.js").SlashCommandOptionsOnlyBuilder;
+    addChannelOption(input: SlashCommandChannelOption | ((builder: SlashCommandChannelOption) => SlashCommandChannelOption)): import("discord.js").SlashCommandOptionsOnlyBuilder;
+    addRoleOption(input: SlashCommandRoleOption | ((builder: SlashCommandRoleOption) => SlashCommandRoleOption)): import("discord.js").SlashCommandOptionsOnlyBuilder;
+    addMentionableOption(input: SlashCommandMentionableOption | ((builder: SlashCommandMentionableOption) => SlashCommandMentionableOption)): import("discord.js").SlashCommandOptionsOnlyBuilder;
+    addAttachmentOption(input: SlashCommandAttachmentOption | ((builder: SlashCommandAttachmentOption) => SlashCommandAttachmentOption)): import("discord.js").SlashCommandOptionsOnlyBuilder;
+    addSubcommand(input: SlashCommandSubcommandBuilder | ((subcommandGroup: SlashCommandSubcommandBuilder) => SlashCommandSubcommandBuilder)): import("discord.js").SlashCommandSubcommandsOnlyBuilder;
+    addSubcommandGroup(input: SlashCommandSubcommandGroupBuilder | ((subcommandGroup: SlashCommandSubcommandGroupBuilder) => SlashCommandSubcommandGroupBuilder)): import("discord.js").SlashCommandSubcommandsOnlyBuilder;
     toJSON(): ApplicationJSONBody;
     toClientJSON(_client: Client): ReturnType<ApplicationCommandBuilder["toJSON"]>;
+    private assertNoMixedTopLevelOptionTypes;
 }

package/dist/structures/builder/Command.d.ts

@@ -1,21 +1,33 @@
-import { ChatInputCommandInteraction, Message } from "discord.js";
-import { Context, Client } from "../index";
-import { MaybePromise } from "#types/extra.js";
-import { Logger } from "../../utils/index";
-import { ApplicationCommandBuilder } from "./Builder";
-type MessageContext = NonNullable<ReturnType<Context<Message>["toJSON"]>>;
-type InteractionContext = NonNullable<ReturnType<Context<ChatInputCommandInteraction>["toJSON"]>>;
+import { Client } from "../index.js";
+import { Logger } from "../../utils/index.js";
+import type { MaybePromise } from "#types/extra.js";
+import { ApplicationCommandBuilder } from "../builder/Builder.js";
+import type { InteractionContextJSON, MessageContextJSON } from "../builder/Context.js";
+type MessageContext = MessageContextJSON;
+type InteractionContext = InteractionContextJSON;
+type CommandContext = MessageContext | InteractionContext;
 export declare class CommandBuilder {
     #private;
     readonly data: ApplicationCommandBuilder;
-    readonly client: Client;
-    readonly logger: Logger;
     _onMessage?: (ctx: MessageContext) => MaybePromise<void>;
     _onInteraction?: (ctx: InteractionContext) => MaybePromise<void>;
-    get supportsSlash(): false | ((ctx: InteractionContext) => MaybePromise<void>) | undefined;
-    get supportsPrefix(): false | ((ctx: MessageContext) => MaybePromise<void>) | undefined;
+    protected createContextHandler<T extends CommandContext>(primary: ((ctx: T) => MaybePromise<void>) | undefined, fallback: ((ctx: CommandContext) => MaybePromise<void>) | undefined): ((ctx: T) => MaybePromise<void>) | undefined;
+    get client(): Client;
+    get logger(): Logger;
+    get supportsSlash(): boolean;
+    get supportsPrefix(): boolean;
     constructor(data: ApplicationCommandBuilder);
+    attach(client: Client): this;
     onMessage(func: (ctx: MessageContext) => MaybePromise<void>): this;
     onInteraction(func: (ctx: InteractionContext) => MaybePromise<void>): this;
 }
+export interface CommandOptions {
+    data: ApplicationCommandBuilder;
+    execute?: (ctx: CommandContext) => MaybePromise<void>;
+    onMessage?: (ctx: MessageContext) => MaybePromise<void>;
+    onInteraction?: (ctx: InteractionContext) => MaybePromise<void>;
+}
+export declare class Command extends CommandBuilder {
+    constructor(options: CommandOptions);
+}
 export {};

package/dist/structures/builder/Context.d.ts

@@ -1,6 +1,6 @@
-import { Message, User, ChatInputCommandInteraction, Locale } from "discord.js";
-import { Client } from "../index";
-import { TOptions } from "i18next";
+import { ChatInputCommandInteraction, Locale, Message, User } from "discord.js";
+import type { TOptions } from "i18next";
+import type { Client } from "../index.js";
 type ContextPayload<T extends ChatInputCommandInteraction | Message> = T extends ChatInputCommandInteraction ? {
     interaction: T;
     args?: string[];
@@ -8,7 +8,30 @@ type ContextPayload<T extends ChatInputCommandInteraction | Message> = T extends
     message: T;
     args?: string[];
 };
+type TranslateFn = (key: string, options?: TOptions & {
+    defaultValue?: string;
+}) => string;
+type DefaultLocalizationFn = (key: string, fallback?: string) => string;
+type LocalizationAliasesFn = (key: string, fallback?: string | string[]) => string[];
+export interface InteractionContextJSON {
+    kind: "interaction";
+    interaction: ChatInputCommandInteraction;
+    author: User | null;
+    t: TranslateFn;
+    getDefaultLocalization: DefaultLocalizationFn;
+    getLocalizationAliases: LocalizationAliasesFn;
+}
+export interface MessageContextJSON {
+    kind: "message";
+    message: Message;
+    args: string[];
+    author: User | null;
+    t: TranslateFn;
+    getDefaultLocalization: DefaultLocalizationFn;
+    getLocalizationAliases: LocalizationAliasesFn;
+}
 export declare class Context<T extends ChatInputCommandInteraction | Message> {
+    #private;
     readonly client: Client;
     readonly args: string[];
     readonly data: T;
@@ -17,23 +40,15 @@ export declare class Context<T extends ChatInputCommandInteraction | Message> {
     isInteraction(): this is Context<ChatInputCommandInteraction>;
     isMessage(): this is Context<Message>;
     get author(): User | null;
+    private resolveIdentityToken;
+    private resolveContextToken;
+    private resolveTemplateToken;
     t(key: string, options?: TOptions & {
         defaultValue?: string;
     }): string;
-    toJSON(): {
-        kind: "interaction";
-        interaction: T;
-        author: User | null;
-        t: any;
-        message?: undefined;
-        args?: undefined;
-    } | {
-        kind: "message";
-        message: Message;
-        args: string[];
-        author: User | null;
-        t: any;
-        interaction?: undefined;
-    };
+    getDefaultLocalization(key: string, fallback?: string): string;
+    getLocalizationAliases(key: string, fallback?: string | string[]): string[];
+    toJSON(this: Context<ChatInputCommandInteraction>): InteractionContextJSON;
+    toJSON(this: Context<Message>): MessageContextJSON;
 }
 export {};

package/dist/structures/builder/Event.d.ts

@@ -1,16 +1,17 @@
-import { ClientEvents } from "discord.js";
-import { MaybePromise } from "#types/extra.js";
-import { Client } from "../index";
-import { Logger } from "../../utils/index";
+import type { ClientEvents } from "discord.js";
+import type { MaybePromise } from "#types/extra.js";
+import { Client } from "../index.js";
+import { Logger } from "../../utils/index.js";
 type EventArgs<K extends keyof ClientEvents> = ClientEvents[K];
 type EventHandler<K extends keyof ClientEvents> = (context: EventBuilder<K>, ...args: EventArgs<K>) => MaybePromise<void>;
 export declare class EventBuilder<K extends keyof ClientEvents> {
     #private;
     readonly name: K;
     readonly once: boolean;
-    readonly client: Client;
-    readonly logger: Logger;
+    get client(): Client;
+    get logger(): Logger;
     constructor(name: K, once?: boolean, _handler?: EventHandler<K>);
+    attach(client: Client): this;
     onExecute(func: EventHandler<K>): this;
 }
 export {};

package/dist/structures/builder/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./Command";
-export * from "./Context";
-export * from "./Event";
-export * from "./Builder";
+export * from "./Command.js";
+export * from "./Context.js";
+export * from "./Event.js";
+export * from "./Builder.js";

package/dist/structures/core/Client.d.ts

@@ -1,19 +1,42 @@
 import { Client as DiscordClient, Collection, IntentsBitField } from "discord.js";
-import { CommandBuilder } from "../index";
-import { Logger } from "../../utils";
-import { FrameworkOptions } from "#types/client.js";
-import { i18n } from "i18next";
+import type { i18n } from "i18next";
+import type { FrameworkOptions, ModuleExport, PrefixFn, TemplateContext, TemplateParserFn } from "#types/client.js";
+import { Logger } from "../../utils/index.js";
+import { CommandBuilder } from "../index.js";
 export declare class Client<Ready extends boolean = boolean> extends DiscordClient<Ready> {
     #private;
     readonly logger: Logger;
     commands: Collection<string, CommandBuilder>;
-    aliases: Collection<string, Set<string>>;
-    readonly prefix: string | false;
+    private slashCommandLookup;
+    private prefixCommandLookup;
+    private readonly templateParsers;
+    readonly prefix: PrefixFn;
     i18n: i18n | undefined;
+    readonly i18next: {
+        readonly instance: i18n | undefined;
+        readonly parser: {
+            addParser: (parser: TemplateParserFn) => void;
+            removeParser: (parser: TemplateParserFn) => boolean;
+            clearParsers: () => void;
+        };
+    };
     options: Omit<FrameworkOptions, "intents"> & {
         intents: IntentsBitField;
     };
     constructor(opts: FrameworkOptions);
     login(token?: string): Promise<string>;
+    registerExport(exported: ModuleExport, source: string, factoryDepth?: number): Promise<void>;
+    private normalizeCommandName;
+    invalidateCommandLookupCache(): void;
+    addTemplateParser(parser: TemplateParserFn): void;
+    removeTemplateParser(parser: TemplateParserFn): boolean;
+    clearTemplateParsers(): void;
+    parseTemplateToken(key: string, context: TemplateContext): string | undefined;
+    private buildCommandLookup;
+    private getSlashCommandLookup;
+    private getPrefixCommandLookup;
+    getSlashCommandsPayload(): import("../index.js").ApplicationJSONBody[];
+    resolveInteractionCommand(commandName: string): CommandBuilder | undefined;
+    resolveMessageCommand(commandName: string): CommandBuilder | undefined;
     registerCommands(): Promise<void>;
 }

package/dist/structures/core/index.d.ts

@@ -1 +1 @@
-export * from "./Client";
+export * from "./Client.js";

package/dist/structures/index.d.ts

@@ -1,2 +1,3 @@
-export * from "./core";
-export * from "./builder";
+export * from "./core/index.js";
+export * from "./builder/index.js";
+export * from "./parser/index.js";

package/dist/structures/parser/MessageCommandParser.d.ts

@@ -0,0 +1,25 @@
+import type { MessageContextJSON } from "../builder/Context.js";
+interface IntegerOptionConfig {
+    key: string;
+    fallbackAliases?: string[];
+    defaultValue?: number;
+    startIndex?: number;
+    useFuzzy?: boolean;
+    maxDistance?: number;
+}
+interface MatchOptions {
+    useFuzzy?: boolean;
+    maxDistance?: number;
+}
+export declare class MessageCommandParser {
+    private readonly ctx;
+    readonly args: string[];
+    readonly normalizedArgs: string[];
+    constructor(ctx: MessageContextJSON);
+    static normalizeToken(value: string): string;
+    getAliases(key: string, fallbackAliases?: string[]): string[];
+    private findClosestAlias;
+    matchesArg(index: number, key: string, fallbackAliases?: string[], options?: MatchOptions): boolean;
+    parseIntegerOption(config: IntegerOptionConfig): number;
+}
+export {};

package/dist/structures/parser/index.d.ts

@@ -0,0 +1 @@
+export * from "./MessageCommandParser.js";

package/dist/utils/applicationCommandLocalization.d.ts

@@ -0,0 +1,3 @@
+import type { i18n } from "i18next";
+import type { ApplicationJSONBody } from "../structures/builder/Builder.js";
+export declare const localizeApplicationCommand: (json: ApplicationJSONBody, instance: i18n) => ApplicationJSONBody;

package/dist/utils/builderAutoSet.d.ts

@@ -0,0 +1,7 @@
+type AutoSetTarget = {
+    setName(name: string): unknown;
+    setDescription(description: string): unknown;
+};
+export declare const applyAutoSet: <T extends AutoSetTarget>(target: T, key: string) => T;
+export declare const asCustomBuilder: <T extends object>(builder: object, ctor: new () => T) => T;
+export {};

package/dist/utils/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./util";
-export * from "./Files";
-export * from "./logger/Logger";
+export * from "./util.js";
+export * from "./Files.js";
+export * from "./logger/Logger.js";

package/dist/utils/logger/ILogger.d.ts

@@ -27,50 +27,8 @@ export declare enum LogLevel {
      */
     Fatal = 60,
     /**
-     * An unknown or uncategorized level.
+     * An uncategorized level.
      */
     None = 100
 }
-export interface ILogger {
-    /**
-     * Checks whether a level is supported.
-     * @param level The level to check.
-     */
-    has(level: LogLevel): boolean;
-    /**
-     * Alias of {@link ILogger.write} with {@link LogLevel.Trace} as level.
-     * @param values The values to log.
-     */
-    trace(...values: readonly unknown[]): void;
-    /**
-     * Alias of {@link ILogger.write} with {@link LogLevel.Debug} as level.
-     * @param values The values to log.
-     */
-    debug(...values: readonly unknown[]): void;
-    /**
-     * Alias of {@link ILogger.write} with {@link LogLevel.Info} as level.
-     * @param values The values to log.
-     */
-    info(...values: readonly unknown[]): void;
-    /**
-     * Alias of {@link ILogger.write} with {@link LogLevel.Warn} as level.
-     * @param values The values to log.
-     */
-    warn(...values: readonly unknown[]): void;
-    /**
-     * Alias of {@link ILogger.write} with {@link LogLevel.Error} as level.
-     * @param values The values to log.
-     */
-    error(...values: readonly unknown[]): void;
-    /**
-     * Alias of {@link ILogger.write} with {@link LogLevel.Fatal} as level.
-     * @param values The values to log.
-     */
-    fatal(...values: readonly unknown[]): void;
-    /**
-     * Writes the log message given a level and the value(s).
-     * @param level The log level.
-     * @param values The values to log.
-     */
-    write(level: LogLevel, ...values: readonly unknown[]): void;
-}
+export type { ILogger } from "#types/logger.js";

package/dist/utils/logger/Logger.d.ts

@@ -1,10 +1,12 @@
 import { Console } from "console";
 import type { Color } from "colorette";
 import { Timestamp } from "@sapphire/timestamp";
-import type { ILogger } from "./ILogger";
-import { LogLevel } from "./ILogger";
-import { LoggerModule } from "i18next";
-export { LogLevel } from "./ILogger";
+import type { ILogger } from "./ILogger.js";
+import { LogLevel } from "./ILogger.js";
+import type { LoggerLevelOptions, LoggerOptions, LoggerStyleResolvable, LoggerValues, LoggerTimestampFormatter, LoggerTimestampOptions } from "#types/logger.js";
+import type { LoggerModule } from "i18next";
+export { LogLevel } from "./ILogger.js";
+export type { LoggerFormatOptions, LoggerLevelOptions, LoggerOptions, LoggerStyleOptions, LoggerStyleResolvable, LoggerValues, LoggerTimestampFormatter, LoggerTimestampOptions, } from "#types/logger.js";
 export declare class Logger implements ILogger {
     level: LogLevel;
     readonly formats: Map<LogLevel, LoggerLevel>;
@@ -20,15 +22,15 @@ export declare class Logger implements ILogger {
     static get stylize(): boolean;
     setLevel(level: LogLevel): void;
     has(level: LogLevel): boolean;
-    trace(...values: readonly unknown[]): void;
-    debug(...values: readonly unknown[]): void;
-    info(...values: readonly unknown[]): void;
-    log(...values: readonly unknown[]): void;
-    warn(...values: readonly unknown[]): void;
-    error(...values: readonly unknown[]): void;
-    fatal(...values: readonly unknown[]): void;
-    write(level: LogLevel, ...values: readonly unknown[]): void;
-    protected preprocess(values: readonly unknown[]): string;
+    trace(...values: LoggerValues): void;
+    debug(...values: LoggerValues): void;
+    info(...values: LoggerValues): void;
+    log(...values: LoggerValues): void;
+    warn(...values: LoggerValues): void;
+    error(...values: LoggerValues): void;
+    fatal(...values: LoggerValues): void;
+    write(level: LogLevel, ...values: LoggerValues): void;
+    protected preprocess(values: LoggerValues): string;
     private createFormatMap;
     private createDefaultLevel;
     private getLevelKey;
@@ -57,44 +59,6 @@ export declare class LoggerLevel {
 }
 declare const _default: Logger;
 export default _default;
-export interface LoggerOptions {
-    stdout?: NodeJS.WritableStream;
-    stderr?: NodeJS.WritableStream;
-    defaultFormat?: LoggerLevelOptions;
-    format?: LoggerFormatOptions;
-    level?: LogLevel;
-    join?: string;
-    depth?: number;
-}
-export interface LoggerFormatOptions {
-    trace?: LoggerLevelOptions;
-    debug?: LoggerLevelOptions;
-    info?: LoggerLevelOptions;
-    warn?: LoggerLevelOptions;
-    error?: LoggerLevelOptions;
-    fatal?: LoggerLevelOptions;
-    none?: LoggerLevelOptions;
-}
-export interface LoggerLevelOptions {
-    timestamp?: LoggerTimestampOptions | null;
-    infix?: string;
-    message?: LoggerStyleResolvable | null;
-}
-export interface LoggerTimestampOptions {
-    pattern?: string;
-    utc?: boolean;
-    color?: LoggerStyleResolvable | null;
-    formatter?: LoggerTimestampFormatter;
-}
-export interface LoggerTimestampFormatter {
-    (timestamp: string): string;
-}
-export interface LoggerStyleOptions {
-    effects?: LoggerStyleEffect[];
-    text?: LoggerStyleText;
-    background?: LoggerStyleBackground;
-}
-export type LoggerStyleResolvable = Color | LoggerStyleOptions;
 export declare enum LoggerStyleEffect {
     Reset = "reset",
     Bold = "bold",
@@ -146,7 +110,7 @@ export declare class I18nLoggerAdapter implements LoggerModule {
     private readonly logger;
     readonly type = "logger";
     constructor(logger: Logger);
-    log(...args: unknown[]): void;
-    warn(...args: unknown[]): void;
-    error(...args: unknown[]): void;
+    log(...args: Parameters<LoggerModule["log"]>): void;
+    warn(...args: Parameters<LoggerModule["warn"]>): void;
+    error(...args: Parameters<LoggerModule["error"]>): void;
 }

package/dist/utils/util.d.ts

@@ -1,4 +1,9 @@
-import { PrefixOptions } from "#types/client.js";
-import { InteractionResponse, Message } from "discord.js";
+import { ChatInputCommandInteraction, InteractionResponse, Locale, Message } from "discord.js";
+import type { Context } from "../structures/index.js";
+export declare const allowedLocales: readonly ["id", "en-US", "en-GB", "bg", "zh-CN", "zh-TW", "hr", "cs", "da", "nl", "fi", "fr", "de", "el", "hi", "hu", "it", "ja", "ko", "lt", "no", "pl", "pt-BR", "ro", "ru", "es-ES", "es-419", "sv-SE", "th", "tr", "uk", "vi"];
+export declare function sanitizeDiscordText(value: unknown): string;
+export declare function parseThings<TContext>(value: string, ctx: TContext, resolver: (name: string, ctx: TContext) => string | undefined): string;
+export declare function collectTemplateTokens(value: string): Set<string>;
 export declare function deleteMessageAfterSent(message: Message | InteractionResponse, time?: number): Promise<void>;
-export declare function getPrefix(opts: PrefixOptions): string | false;
+export declare function toAllowedLocale(locale: string | null | undefined): `${Locale}` | undefined;
+export declare function getDefaultLang(ctx: Context<ChatInputCommandInteraction | Message>): `${Locale}`;

package/package.json

@@ -1 +1 @@
-{"name":"@arox/framework","version":"0.1.2-beta.1","description":"","keywords":["arox","discord.js","framework"],"homepage":"https://github.com/AroxBot/framework#readme","bugs":{"url":"https://github.com/AroxBot/framework/issues"},"license":"Apache-2.0","author":"vrdons","contributors":["fhyrox"],"repository":{"type":"git","url":"git+https://github.com/AroxBot/framework.git"},"type":"commonjs","main":"dist/index.js","types":"dist/index.d.ts","imports":{"#types/*":"./types/*"},"dependencies":{"@sapphire/timestamp":"^1.0.5","colorette":"^2.0.20","fast-glob":"^3.3.3","i18next":"^25.8.0"},"peerDependencies":{"discord.js":">=14.25.1"}}
+{"name":"@arox/framework","version":"0.1.3","description":"","keywords":["arox","discord.js","framework"],"homepage":"https://github.com/AroxBot/framework#readme","bugs":{"url":"https://github.com/AroxBot/framework/issues"},"license":"Apache-2.0","author":"vrdons","contributors":["fhyrox"],"repository":{"type":"git","url":"git+https://github.com/AroxBot/framework.git"},"type":"module","main":"dist/index.cjs","module":"dist/index.js","types":"dist/index.d.ts","exports":{".":{"types":"./dist/index.d.ts","require":{"types":"./dist/index.d.cts","default":"./dist/index.cjs"},"import":{"types":"./dist/index.d.ts","default":"./dist/index.js"},"default":"./dist/index.js"}},"dependencies":{"@sapphire/timestamp":"^1.0.5","colorette":"^2.0.20","fast-glob":"^3.3.3","fastest-levenshtein":"^1.0.16","i18next":"^25.8.0"},"peerDependencies":{"discord.js":">=14.25.1"}}

package/types/client.d.ts

@@ -1,22 +1,52 @@
-import { ClientOptions } from "discord.js";
-import { LoggerOptions } from "../src/utils/logger/Logger";
+import {
+	ChatInputCommandInteraction,
+	ClientOptions,
+	Locale,
+	Message,
+} from "discord.js";
+import type { LoggerOptions } from "./logger.js";
 import { i18n } from "i18next";
+import type { Context } from "../src/structures/builder/Context.js";
+import type { CommandBuilder } from "../src/structures/builder/Command.js";
+import type { EventBuilder } from "../src/structures/builder/Event.js";
+import type { Client } from "../src/structures/core/Client.js";
 
-export interface FrameworkPaths {
-	events?: string;
-	commands?: string;
-	locales?: string;
-}
-
-export type PrefixOptions =
-	| { enabled: true; prefix: string }
-	| { enabled: false }
-	| string;
+export type PrefixFn = (ctx: Context<Message>) => string | false;
+export type TemplateContext = Context<ChatInputCommandInteraction | Message>;
+export type GetDefaultLangFn = (
+	ctx: TemplateContext
+) => `${Locale}` | undefined;
+export type TemplateParserFn = (
+	key: string,
+	context: TemplateContext
+) => string | undefined | null;
 
 export interface FrameworkOptions extends ClientOptions {
 	logger?: LoggerOptions;
-	prefix?: PrefixOptions;
+	prefix?: PrefixFn;
+	getDefaultLang?: GetDefaultLangFn;
 	autoRegisterCommands?: boolean;
 	includePaths: string[];
 	i18n?: i18n;
 }
+
+export type AttachableExport = {
+	attach: (client: Client) => void | Promise<void>;
+};
+
+export type ModuleExport =
+	| CommandBuilder
+	| EventBuilder<keyof import("discord.js").ClientEvents>
+	| AttachableExport
+	| ModuleExportFactory
+	| readonly ModuleExport[]
+	| null
+	| undefined;
+
+/**
+ * Factory function that produces module exports.
+ * The implementation must handle nested factories with appropriate depth limiting.
+ */
+export type ModuleExportFactory = (
+	client: Client
+) => ModuleExport | Promise<ModuleExport>;

package/types/logger.d.ts

@@ -0,0 +1,66 @@
+import type { Color } from "colorette";
+import type { Console } from "node:console";
+import type { LogLevel } from "../src/utils/logger/ILogger.js";
+import type {
+	LoggerStyleBackground,
+	LoggerStyleEffect,
+	LoggerStyleText,
+} from "../src/utils/logger/Logger.js";
+
+export interface ILogger {
+	has(level: LogLevel): boolean;
+	trace(...values: LoggerValues): void;
+	debug(...values: LoggerValues): void;
+	info(...values: LoggerValues): void;
+	warn(...values: LoggerValues): void;
+	error(...values: LoggerValues): void;
+	fatal(...values: LoggerValues): void;
+	write(level: LogLevel, ...values: LoggerValues): void;
+}
+
+export interface LoggerOptions {
+	stdout?: NodeJS.WritableStream;
+	stderr?: NodeJS.WritableStream;
+	defaultFormat?: LoggerLevelOptions;
+	format?: LoggerFormatOptions;
+	level?: LogLevel;
+	join?: string;
+	depth?: number;
+}
+
+export interface LoggerFormatOptions {
+	trace?: LoggerLevelOptions;
+	debug?: LoggerLevelOptions;
+	info?: LoggerLevelOptions;
+	warn?: LoggerLevelOptions;
+	error?: LoggerLevelOptions;
+	fatal?: LoggerLevelOptions;
+	none?: LoggerLevelOptions;
+}
+
+export interface LoggerLevelOptions {
+	timestamp?: LoggerTimestampOptions | null;
+	infix?: string;
+	message?: LoggerStyleResolvable | null;
+}
+
+export interface LoggerTimestampOptions {
+	pattern?: string;
+	utc?: boolean;
+	color?: LoggerStyleResolvable | null;
+	formatter?: LoggerTimestampFormatter;
+}
+
+export interface LoggerTimestampFormatter {
+	(timestamp: string): string;
+}
+
+export interface LoggerStyleOptions {
+	effects?: LoggerStyleEffect[];
+	text?: LoggerStyleText;
+	background?: LoggerStyleBackground;
+}
+
+export type LoggerValues = Parameters<Console["log"]>;
+
+export type LoggerStyleResolvable = Color | LoggerStyleOptions;