bakit 2.0.0-alpha.8 → 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Louis Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -1,423 +1,4 @@
-import * as discord_js from 'discord.js';
-import { GatewayIntentBits, ClientOptions, ChatInputCommandInteraction, CacheType, Message, User, MessageCreateOptions, InteractionReplyOptions, Awaitable, Collection, Events, IntentsBitField, Client, ClientEvents } from 'discord.js';
-import z$1, { z } from 'zod';
-import * as jiti from 'jiti';
-import { inspect } from 'node:util';
-
-declare const ProjectConfigSchema: z.ZodObject<{
-    intents: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodBigInt, z.ZodArray<z.ZodEnum<typeof GatewayIntentBits>>]>>;
-    clientOptions: z.ZodOptional<z.ZodCustom<Omit<ClientOptions, "intents">, Omit<ClientOptions, "intents">>>;
-    entryDir: z.ZodDefault<z.ZodString>;
-    prefixes: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    token: z.ZodString;
-}, z.core.$strip>;
-type ProjectConfigInput = z.input<typeof ProjectConfigSchema>;
-type ProjectConfig = z.output<typeof ProjectConfigSchema>;
-/**
- * Define config object for your project. This is just a cleaner way to define config.
- * @param config The partial version of project config.
- * @returns The same config you provided earlier.
- */
-declare function defineConfig(config: ProjectConfigInput): ProjectConfigInput;
-/**
- * Load the config file and save them for later usage.
- * @param cwd The location of the config file, uses root by default.
- * @returns The complete config with default values from the validation.
- */
-declare function loadConfig(cwd?: string): Promise<ProjectConfig>;
-/**
- * Get the loaded config of the project.
- * @returns The project config.
- */
-declare function getConfig(): ProjectConfig;
-
-declare const EVENT_INTENT_MAPPING: Record<string, number[]>;
-
-declare function tokenize(content: string): string[];
-
-declare const $jiti: jiti.Jiti;
-
-declare class Context {
-    canceled: boolean;
-    cancel(): void;
-}
-
-type ChatInputContextSendOptions = string | InteractionReplyOptions;
-type MessageContextSendOptions = string | MessageCreateOptions;
-type ContextSendOptions = ChatInputContextSendOptions | MessageContextSendOptions;
-declare abstract class BaseCommandContext<Cached extends boolean, InGuild extends boolean> extends Context {
-    source: ChatInputCommandInteraction<Cached extends true ? "cached" : CacheType> | Message<InGuild>;
-    constructor(source: ChatInputCommandInteraction<Cached extends true ? "cached" : CacheType> | Message<InGuild>);
-    get client(): BakitClient<true>;
-    get channel(): discord_js.CacheTypeReducer<Cached extends true ? "cached" : CacheType, discord_js.GuildTextBasedChannel | null, discord_js.GuildTextBasedChannel | null, discord_js.GuildTextBasedChannel | null, discord_js.TextBasedChannel | null> | discord_js.If<InGuild, discord_js.GuildTextBasedChannel, discord_js.TextBasedChannel>;
-    get channelId(): string;
-    get guild(): discord_js.CacheTypeReducer<Cached extends true ? "cached" : CacheType, discord_js.Guild, null, discord_js.Guild | null, discord_js.Guild | null> | discord_js.If<InGuild, discord_js.Guild, null>;
-    get guildId(): discord_js.CacheTypeReducer<Cached extends true ? "cached" : CacheType, string, string, string, string | null> | discord_js.If<InGuild, string, null>;
-    get member(): discord_js.GuildMember | discord_js.CacheTypeReducer<Cached extends true ? "cached" : CacheType, discord_js.GuildMember, discord_js.APIInteractionGuildMember, discord_js.GuildMember | discord_js.APIInteractionGuildMember, discord_js.GuildMember | discord_js.APIInteractionGuildMember | null> | null;
-    inGuild(): this is CommandContext<Cached, true>;
-    inCachedGuild(): this is CommandContext<true, true>;
-    get user(): User;
-    isChatInput(): this is ChatInputContext;
-    isMessage(): this is MessageContext;
-    abstract send(options: ContextSendOptions): Promise<Message<InGuild>>;
-}
-declare class ChatInputContext<Cached extends boolean = boolean, InGuild extends boolean = boolean> extends BaseCommandContext<Cached, InGuild> {
-    source: ChatInputCommandInteraction<Cached extends true ? "cached" : CacheType>;
-    send(options: ContextSendOptions): Promise<Message<InGuild>>;
-}
-declare class MessageContext<Cached extends boolean = boolean, InGuild extends boolean = boolean> extends BaseCommandContext<Cached, InGuild> {
-    source: Message<InGuild>;
-    send(options: string | MessageCreateOptions): Promise<Message<InGuild>>;
-}
-type CommandContext<Cached extends boolean = boolean, InGuild extends boolean = boolean> = ChatInputContext<Cached, InGuild> | MessageContext<Cached, InGuild>;
-
-declare enum HookState {
-    Pre = "PRE",
-    Main = "MAIN",
-    Post = "POST",
-    Error = "ERROR"
-}
-declare enum HookOrder {
-    First = 0,
-    Last = 1
-}
-type MainHookCallback<C extends Context, Args extends unknown[]> = (context: C, ...args: Args) => Awaitable<void>;
-type ErrorHookCallback<C extends Context, Args extends unknown[]> = (context: C, error: unknown, ...args: Args) => Awaitable<void>;
-declare class LifecycleManager<C extends Context, Args extends unknown[]> {
-    id: string;
-    private readonly hooks;
-    constructor(id: string);
-    getName(name: string): string;
-    setHook(name: string, state: HookState.Post, callback: MainHookCallback<C, Args>, order?: HookOrder): this;
-    setHook(name: string, state: HookState.Main, callback: MainHookCallback<C, Args>, order?: HookOrder): this;
-    setHook(name: string, state: HookState.Pre, callback: MainHookCallback<C, Args>, order?: HookOrder): this;
-    setHook(name: string, state: HookState.Error, callback: ErrorHookCallback<C, Args>, order?: HookOrder): this;
-    main(callback: MainHookCallback<C, Args>): this;
-    pre(callback: MainHookCallback<C, Args>): this;
-    post(callback: MainHookCallback<C, Args>): this;
-    error(callback: ErrorHookCallback<C, Args>): this;
-    execute(context: C, ...args: Args): Promise<void>;
-}
-
-declare enum ParamUserType {
-    Bot = "bot",
-    Normal = "normal",
-    Any = "any"
-}
-declare const BaseParamSchema: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    required: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strip>;
-declare const StringParamSchema: z.ZodPipe<z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    required: z.ZodDefault<z.ZodBoolean>;
-    maxLength: z.ZodOptional<z.ZodNumber>;
-    minLength: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>, z.ZodTransform<{
-    name: string;
-    required: boolean;
-    description?: string | undefined;
-    maxLength?: number | undefined;
-    minLength?: number | undefined;
-} & {
-    description: string;
-}, {
-    name: string;
-    required: boolean;
-    description?: string | undefined;
-    maxLength?: number | undefined;
-    minLength?: number | undefined;
-}>>;
-declare const NumberParamSchema: z.ZodPipe<z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    required: z.ZodDefault<z.ZodBoolean>;
-    maxValue: z.ZodOptional<z.ZodNumber>;
-    minValue: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>, z.ZodTransform<{
-    name: string;
-    required: boolean;
-    description?: string | undefined;
-    maxValue?: number | undefined;
-    minValue?: number | undefined;
-} & {
-    description: string;
-}, {
-    name: string;
-    required: boolean;
-    description?: string | undefined;
-    maxValue?: number | undefined;
-    minValue?: number | undefined;
-}>>;
-type BaseParamOptions = z.input<typeof BaseParamSchema>;
-type StringOptions = z.input<typeof StringParamSchema>;
-type NumberOptions = z.input<typeof NumberParamSchema>;
-
-type ParamResolvedOutputType<OutputType, Required extends boolean = true> = Required extends true ? OutputType : OutputType | null;
-declare abstract class BaseParam<Options extends BaseParamOptions, OutputType, Required extends boolean = true> {
-    options: Options & {
-        required: Required;
-    };
-    /**
-     * **Internal Phantom Type**
-     *
-     * Used strictly for TypeScript type inference to determine the runtime value
-     * of this parameter. This property does not exist at runtime.
-     *
-     * @internal
-     */
-    readonly _type: Required extends true ? OutputType : OutputType | null;
-    constructor(options: Options);
-    protected setOption(key: keyof Options, value: any): this;
-    name(value: string): this;
-    description(value: string): this;
-    required<V extends boolean>(value: V): BaseParam<Options, OutputType, V>;
-    resolve(context: CommandContext, value?: string): Promise<ParamResolvedOutputType<OutputType, Required>>;
-    abstract resolveMessage(context: MessageContext, value: string | undefined): Awaitable<ParamResolvedOutputType<OutputType, Required>>;
-    abstract resolveChatInput(context: ChatInputContext): Awaitable<ParamResolvedOutputType<OutputType, Required>>;
-    /**
-     * Helper to normalize string inputs into an options object.
-     */
-    protected static getOptions<Options>(options: Options | string): Options;
-}
-declare class StringParam<Required extends boolean = true> extends BaseParam<StringOptions, string, Required> {
-    constructor(options: string | StringOptions);
-    required<V extends boolean>(value: V): StringParam<V>;
-    resolveMessage(_context: CommandContext, value: string | undefined): ParamResolvedOutputType<string, Required>;
-    resolveChatInput(context: ChatInputContext): ParamResolvedOutputType<string, Required>;
-    /**
-     * Sets the minimum allowed length for this string.
-     * Pass `null` to remove this constraint.
-     */
-    min(length: number | null): this;
-    /**
-     * Sets the maximum allowed length for this string.
-     * Pass `null` to remove this constraint.
-     */
-    max(length: number | null): this;
-}
-declare class NumberParam<Required extends boolean = true> extends BaseParam<NumberOptions, number, Required> {
-    constructor(options: string | NumberOptions);
-    required<V extends boolean>(value: V): NumberParam<V>;
-    resolveMessage(ctx: CommandContext, value: string | undefined): ParamResolvedOutputType<number, Required>;
-    resolveChatInput(context: ChatInputContext): ParamResolvedOutputType<number, Required>;
-    /**
-     * Sets the minimum allowed value for this number.
-     * Pass `null` to remove this constraint.
-     */
-    min(value: number | null): this;
-    /**
-     * Sets the maximum allowed value for this number.
-     * Pass `null` to remove this constraint.
-     */
-    max(value: number | null): this;
-}
-type AnyParam<Required extends boolean = true> = BaseParam<any, any, Required>;
-/**
- * Helper type to extract the runtime value of a Param instance.
- *
- * @example
- * const p = new StringParam("name").required(false);
- * type T = InferParamValue<typeof p>; // string | null
- */
-type InferParamValue<P extends AnyParam<any>> = P["_type"];
-type InferParamTuple<T extends readonly BaseParam<any, any, any>[]> = {
-    [K in keyof T]: T[K] extends AnyParam<any> ? InferParamValue<T[K]> : never;
-};
-
-declare function validateParamsOrder(params: readonly AnyParam<boolean>[]): boolean;
-declare const CommandOptionsSchema: z.ZodPipe<z.ZodObject<{
-    name: z.ZodReadonly<z.ZodString>;
-    description: z.ZodReadonly<z.ZodOptional<z.ZodString>>;
-    nsfw: z.ZodReadonly<z.ZodDefault<z.ZodBoolean>>;
-    params: z.ZodReadonly<z.ZodDefault<z.ZodArray<z.ZodCustom<BaseParam<{
-        name: string;
-        description?: string | undefined;
-        required?: boolean | undefined;
-    }, unknown, boolean>, BaseParam<{
-        name: string;
-        description?: string | undefined;
-        required?: boolean | undefined;
-    }, unknown, boolean>>>>>;
-    quotes: z.ZodReadonly<z.ZodDefault<z.ZodBoolean>>;
-}, z.core.$strip>, z.ZodTransform<{
-    description: string;
-    name: string;
-    nsfw: boolean;
-    params: readonly BaseParam<{
-        name: string;
-        description?: string | undefined;
-        required?: boolean | undefined;
-    }, unknown, boolean>[];
-    quotes: boolean;
-}, {
-    name: string;
-    nsfw: boolean;
-    params: readonly BaseParam<{
-        name: string;
-        description?: string | undefined;
-        required?: boolean | undefined;
-    }, unknown, boolean>[];
-    quotes: boolean;
-    description?: string | undefined;
-}>>;
-type CommandOptionsInput = z.input<typeof CommandOptionsSchema>;
-type CommandOptions = z.output<typeof CommandOptionsSchema>;
-/**
- * The command entry, used for registering command.
- */
-declare class Command<ParamsList extends readonly AnyParam<any>[] = any[]> extends LifecycleManager<CommandContext, [
-    ...args: InferParamTuple<ParamsList>
-]> {
-    options: CommandOptions;
-    constructor(options: (Omit<CommandOptionsInput, "params"> & {
-        params?: ParamsList;
-    }) | string);
-    private handleSyntaxError;
-    toSlashCommandJSON(): discord_js.RESTPostAPIChatInputApplicationCommandsJSONBody;
-    private initSlashCommandOptions;
-    private initSlashCommandOption;
-}
-/**
- * Define command entry, usually for modules.
- * @param options The command options.
- * @returns The entry of the command to deploy or register hooks.
- * @example
- * ```ts
- * import { defineCommand } from "bakit";
- *
- * const command = defineCommand({
- * 	name: "ping",
- * 	description: "Displays bot's latency.",
- * });
- *
- * command.main(async (context) => {
- * 	await context.send(`Pong! ${context.client.ws.ping}ms!`);
- * });
- *
- * export default command;
- * ```
- */
-declare function defineCommand<const ParamsList extends readonly AnyParam<any>[] = any[]>(options: (Omit<CommandOptionsInput, "params"> & {
-    params?: ParamsList;
-}) | string): Command<ParamsList>;
-
-declare class CommandManager extends BaseClientManager {
-    commands: Collection<string, Command<any[]>>;
-    loadModules(): Promise<Command[]>;
-    add(command: Command): void;
-    remove(target: string | Command): Command | undefined;
-    get(name: string): Command<any[]> | undefined;
-}
-
-declare const ListenerOptionsSchema: z$1.ZodObject<{
-    name: z$1.ZodEnum<typeof Events>;
-    once: z$1.ZodDefault<z$1.ZodBoolean>;
-}, z$1.z.core.$strip>;
-type ListenerOptions<K extends EventKey = EventKey> = Omit<z$1.input<typeof ListenerOptionsSchema>, "name"> & {
-    name: K;
-};
-type EventKey = keyof BakitClientEvents;
-declare class Listener<K extends EventKey = EventKey> extends LifecycleManager<Context, [
-    ...args: BakitClientEvents[K]
-]> {
-    options: ListenerOptions<K>;
-    constructor(options: K | ListenerOptions<K>);
-}
-declare function defineListener<const K extends EventKey = EventKey>(options: K | ListenerOptions<K>): Listener<K>;
-
-declare class ListenerManager extends BaseClientManager {
-    listeners: Listener[];
-    private executors;
-    loadModules(): Promise<Listener[]>;
-    add(listener: Listener): void;
-    remove(target: string | Listener): Listener[];
-    getBaseIntents(): IntentsBitField;
-    getNeededIntents(): IntentsBitField;
-}
-
-declare class ProjectCacheManager {
-    private readonly rootDir;
-    constructor(root?: string);
-    private ensureRoot;
-    getHash(data: unknown): string;
-    write(path: string, data: unknown): Promise<void>;
-    read<T>(path: string): Promise<T | null>;
-    clear(): Promise<void>;
-    clearSync(): void;
-}
-
-declare class Instance {
-    client: BakitClient;
-    cache: ProjectCacheManager;
-    constructor();
-    start(): Promise<void>;
-    private loadModules;
-    private initIntents;
-}
-declare function useApp(): Instance;
-
-type GetPrefixFunction = (message: Message) => Awaitable<string[] | string>;
-interface BakitClientEvents extends ClientEvents {
-    ready: [BakitClient<true>];
-    clientReady: [BakitClient<true>];
-}
-declare class BakitClient<Ready extends boolean = boolean> extends Client<Ready> {
-    instance: Instance;
-    managers: {
-        commands: CommandManager;
-        listeners: ListenerManager;
-    };
-    constructor(options: ClientOptions, instance: Instance);
-    /**
-     * Check if the client is connected to gateway successfully and finished initialization.
-     */
-    isReady(): this is BakitClient<true>;
-    on<K extends keyof BakitClientEvents>(event: K, listener: (...args: BakitClientEvents[K]) => void): this;
-    once<K extends keyof BakitClientEvents>(event: K, listener: (...args: BakitClientEvents[K]) => void): this;
-    off<K extends keyof BakitClientEvents>(event: K, listener: (...args: BakitClientEvents[K]) => void): this;
-    removeAllListeners(event?: keyof BakitClientEvents): this;
-    removeListener<K extends keyof BakitClientEvents>(event: K, listener: (...args: BakitClientEvents[K]) => void): this;
-    emit<K extends keyof BakitClientEvents>(event: K, ...args: BakitClientEvents[K]): boolean;
-    /**
-     * Override BakitClient output when using logger for security concern.
-     * @returns `BakitClient {}`
-     */
-    [inspect.custom](): string;
-}
-
-declare class BaseClientManager {
-    client: BakitClient;
-    constructor(client: BakitClient);
-}
-
-declare const Params: {
-    readonly string: <Required extends boolean = true>(options: string | {
-        name: string;
-        description?: string | undefined;
-        required?: boolean | undefined;
-        maxLength?: number | undefined;
-        minLength?: number | undefined;
-    }) => StringParam<Required>;
-    readonly number: <Required extends boolean = true>(options: string | {
-        name: string;
-        description?: string | undefined;
-        required?: boolean | undefined;
-        maxValue?: number | undefined;
-        minValue?: number | undefined;
-    }) => NumberParam<Required>;
-};
-
-declare class BakitError extends Error {
-    constructor(message: string);
-}
-
-declare class ArgumentError extends BakitError {
-    target: string;
-    reason: string;
-    constructor(target: string, reason: string);
-}
-
-export { $jiti, type AnyParam, ArgumentError, BakitClient, type BakitClientEvents, BakitError, BaseClientManager, BaseCommandContext, BaseParam, type BaseParamOptions, BaseParamSchema, ChatInputContext, type ChatInputContextSendOptions, Command, type CommandContext, CommandManager, type CommandOptions, type CommandOptionsInput, CommandOptionsSchema, Context, type ContextSendOptions, EVENT_INTENT_MAPPING, type ErrorHookCallback, type GetPrefixFunction, HookOrder, HookState, type InferParamTuple, type InferParamValue, Instance, LifecycleManager, Listener, ListenerManager, type ListenerOptions, ListenerOptionsSchema, type MainHookCallback, MessageContext, type MessageContextSendOptions, type NumberOptions, NumberParam, NumberParamSchema, type ParamResolvedOutputType, ParamUserType, Params, type ProjectConfig, type ProjectConfigInput, ProjectConfigSchema, type StringOptions, StringParam, StringParamSchema, defineCommand, defineConfig, defineListener, getConfig, loadConfig, tokenize, useApp, validateParamsOrder };
+export { DEFAULT_GATEWAY_MANAGER_OPTIONS, DEFAULT_WORKER_PATH, GatewayManager, GatewayManagerEvents, GatewayManagerOptions, GatewayWorker, GatewayWorkerEvents, GatewayWorkerOptions, GatewayWorkerState, createGatewayManager, createWorker } from '@bakit/gateway';
+export { REST, RESTEndpoint, RESTEvents, RESTMethod, RESTOptions, RESTTransportServer, RESTTransportServerOptions, createREST, createRESTTransportServer } from '@bakit/rest';
+export { Awaitable, Collection, EventBus, EventMap, FunctionLike, Promisify, PromisifyValue, Queue, QueueOptions, ReadonlyCollection, RejectFn, ResolveFn, attachEventBus, capitalize, createEventBus, createQueue, isPlainObject, isPromiseLike, promisify, sleep } from '@bakit/utils';
+export { RPCError, RPCErrorPayload, RPCHandler, RPCRequestMessage, RPCResponseMessage, Serializable, Service, ServiceClient, ServiceFunction, ServiceOptions, ServiceServer, TransportClient, TransportClientOptions, TransportDriver, TransportEvents, TransportServer, TransportServerOptions, createIPCClient, createIPCServer, createService, createServiceClient, createServiceServer, createTransportClient, createTransportServer, deserializeRPCError, getIPCPath, serializeRPCError } from '@bakit/service';