@constatic/base 0.0.1-beta.10 → 0.0.1-beta.12

package/dist/bootstrap.d.ts

@@ -2,18 +2,67 @@ import { type Client } from "discord.js";
 import { type BaseErrorHandler } from "./app.js";
 import { type CustomClientOptions } from "./client.js";
 export interface BootstrapOptions extends CustomClientOptions {
-    token?: string;
+    /**
+     * The caller module's `import.meta`.
+     * Internally used for resolving file paths when dynamically loading modules.
+     */
     meta: ImportMeta;
+    /**
+     * The Discord bot token.
+     * If omitted, bootstrap will attempt to use:
+     * - `env.BOT_TOKEN`
+     * - `process.env.BOT_TOKEN`
+     */
+    token?: string;
+    /**
+     * A custom error handler that overrides the default one
+     * configured by `ConstaticApp`.
+     *
+     * If provided, all global errors such as:
+     * - `uncaughtException`
+     * - `unhandledRejection`
+     *
+     * will be handled by this function.
+     */
     errorHandler?: BaseErrorHandler;
+    /**
+     * A hook executed before loading the modules.
+     * Can be used to register services, prepare caches,
+     * validate dependencies, or modify the client before initialization.
+     */
     beforeLoad?(client: Client<boolean>): Promise<void>;
+    /**
+     * Additional glob patterns used to load application modules.
+     */
     modules?: string[];
+    /**
+     * Whether initialization logs should be displayed.
+     * Defaults to `true`.
+     */
     loadLogs?: boolean;
+    /**
+     * Custom environment variables that may complement or override
+     * values from `process.env`.
+     */
     env?: Record<string, any>;
 }
+/**
+ *
+ * Bootstraps and initializes a Constatic application, creating the Discord client,
+ * loading modules, registering events, and applying global error handlers.
+ *
+ * @example
+ * import { bootstrap } from "@constatic/base";
+ *
+ * await bootstrap({ meta: import.meta });
+ *
+ * @example
+ * import { env } from "#env";
+ * import { bootstrap } from "@constatic/base";
+ *
+ * await bootstrap({ meta: import.meta, env });
+ */
 export declare function bootstrap(options: BootstrapOptions): Promise<{
     client: Client<boolean>;
-    imports: {
-        module: any;
-        filepath: string;
-    }[];
+    imports: import("./modules.js").ModuleImported[];
 }>;

package/dist/client.d.ts

@@ -1,3 +1,12 @@
 import { Client, type ClientOptions } from "discord.js";
 export type CustomClientOptions = Partial<ClientOptions>;
+/**
+ * Creates and configures a Discord.js client instance integrated with ConstaticApp.
+ *
+ * This function initializes a `Client`, assigns the provided bot token, binds
+ * lifecycle events, and automatically wires command handlers, autocomplete
+ * handlers, and general interaction responders from the Constatic framework.
+ *
+ * The client will log a formatted startup message once it becomes ready.
+ */
 export declare function createClient(token: string, options: CustomClientOptions): Client<boolean>;

package/dist/creators/setup.d.ts

@@ -10,6 +10,29 @@ export interface SetupCreatorsOptions {
     responders?: Partial<BaseRespondersConfig>;
     events?: Partial<BaseEventsConfig>;
 }
+/**
+ * Initializes the Constatic command/event/responder creation system.
+ *
+ * This function configures the Constatic application’s internal registries
+ * for commands, events, and responders, and returns a set of factory
+ * functions used to create each type of component.
+ *
+ * It also:
+ * - Applies optional default command permissions
+ * - Merges user-provided config into the ConstaticApp instance
+ * - Automatically injects `process.env.GUILD_ID` into guild-restricted commands
+ * - Ensures `"clientReady"` events always run once
+ *
+ * **Returned creators:**
+ * - `createCommand(data)` — Registers a new slash command (or other command type)
+ * - `createEvent(data)` — Registers a Discord.js event listener
+ * - `createResponder(data)` — Registers an interaction responder (buttons, modals, etc.)
+ *
+ * @example
+ * import { setupCreators } from "@constatic/base";
+ *
+ * export const { createCommand, createResponder, createEvent } = setupCreators();
+ */
 export declare function setupCreators(options?: SetupCreatorsOptions): {
     createCommand<T extends CommandType = ApplicationCommandType.ChatInput, P extends boolean = false, R = void>(data: CommandData<T, P, R>): Command<T, P, R>;
     createEvent: <EventName extends keyof ClientEvents>(data: EventData<EventName>) => Event<EventName>;

package/dist/env.d.ts

@@ -1,5 +1,28 @@
 import type { StandardSchemaV1 } from "./utils/schema.js";
 type Schema = StandardSchemaV1;
 type Out<T extends Schema> = StandardSchemaV1.InferOutput<T>;
+/**
+ * Validates the current process environment variables using a StandardSchema.
+ *
+ * This function executes the schema validation against `process.env`
+ * and ensures all required environment variables follow the expected shape.
+ * @example
+ * // "env.ts" — Using Zod
+ * import { z } from "zod";
+ * import { validateEnv } from "@constatic/base";
+ *
+ * export const env = await validateEnv(z.object({
+ *     BOT_TOKEN: z.string("BOT_TOKEN is required").min(1)
+ * }).passthrough());
+ *
+ * @example
+ * // "env.ts" — Using ArkType
+ * import { type } from "arktype";
+ * import { validateEnv } from "@constatic/base";
+ *
+ * export const env = await validateEnv(type({
+ *     BOT_TOKEN: "string > 0"
+ * }));
+ */
 export declare function validateEnv<T extends Schema>(schema: T): Promise<Out<T>>;
 export {};

package/dist/modules.d.ts

@@ -1,4 +1,9 @@
-export declare function loadModules(meta: ImportMeta, modules?: string[]): Promise<{
+export interface ModuleImported {
     module: any;
     filepath: string;
-}[]>;
+}
+/**
+ * Dynamically loads modules using glob patterns, returning each imported module
+ * along with its file path.
+ */
+export declare function loadModules(meta: ImportMeta, modules?: string[]): Promise<ModuleImported[]>;

package/dist/modules.js

@@ -1,14 +1,17 @@
 // src/modules.ts
 import { glob } from "node:fs/promises";
-import path from "node:path";
+import { join } from "node:path";
 async function loadModules(meta, modules = []) {
-  const exclude = modules.filter((path2) => path2.charAt(0) == "!").map((path2) => path2.slice(1));
+  const exclude = modules.filter((path) => path.charAt(0) == "!").map((path) => path.slice(1));
   const filepaths = await Array.fromAsync(glob(modules, { cwd: meta.dirname, exclude }));
-  const promises = filepaths.map((filepath) => import(path.join(meta.dirname, filepath)).then((imported) => ({
-    module: imported,
-    filepath
-  })));
-  return Promise.all(promises);
+  const loadModules2 = [];
+  for (const path of filepaths) {
+    await import(join(meta.dirname, path)).then((imported) => loadModules2.push({
+      module: imported,
+      filepath: path
+    }));
+  }
+  return loadModules2;
 }
 export {
   loadModules

package/dist/version.d.ts

@@ -1 +1,7 @@
+/**
+ * Represents the current lib version.
+ *
+ * The version follows semantic versioning (SemVer), typically in the format:
+ * `"MAJOR.MINOR.PATCH"` — for example: `"1.0.0"`.
+ */
 export declare const version: string;

package/dist/version.js

@@ -1,5 +1,5 @@
 // src/version.ts
-var version = "0.0.1-beta.10";
+var version = "0.0.1-beta.12";
 export {
   version
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constatic/base",
-  "version": "0.0.1-beta.10",
+  "version": "0.0.1-beta.12",
   "description": "",
   "license": "MIT",
   "type": "module",