@constatic/base 0.1.0 → 0.1.2

package/{dist → build}/bootstrap.d.ts

@@ -45,6 +45,13 @@ export interface BootstrapOptions extends CustomClientOptions {
      * values from `process.env`.
      */
     env?: Record<string, any>;
+    /**
+     * Generates a file with only imports of the automatically loaded modules that are returned by the bootstrap function
+     *
+     * - Define `true` to generate the imports.ts file
+     * - Define a `string` path to activate and customize the file output
+     */
+    generateImportsFile?: boolean | string;
 }
 /**
  *

package/{dist → build}/bootstrap.js

@@ -1,12 +1,13 @@
 // src/bootstrap.ts
+import { join } from "node:path";
 import { ConstaticApp } from "./app.js";
 import { createClient } from "./client.js";
-import { ConstaticError } from "./error.js";
-import { loadModules } from "./modules.js";
+import { Errors } from "./error.js";
+import { generateImportsFile, loadModules } from "./modules.js";
 async function bootstrap(options) {
   const token = options.token ?? options.env?.BOT_TOKEN ?? process.env?.BOT_TOKEN;
   if (!token)
-    throw new ConstaticError("The application token was not provided!");
+    throw Errors.tokenNotProvided();
   const app = ConstaticApp.getInstance();
   if (options.errorHandler) {
     app.setErrorHandler(options.errorHandler);
@@ -28,6 +29,10 @@ async function bootstrap(options) {
   app.intro();
   app.events.register(client);
   client.login();
+  if (options.generateImportsFile) {
+    const outputPath = join(options.meta.dirname, typeof options.generateImportsFile === "string" ? options.generateImportsFile : "imports.ts");
+    await generateImportsFile(options.meta, outputPath, imports);
+  }
   return { client, imports };
 }
 export {

package/{dist → build}/client.js

@@ -13,10 +13,10 @@ function createClient(token, options) {
     failIfNotExists: options.failIfNotExists ?? false
   });
   client.token = token;
-  client.once("clientReady", async (client2) => {
-    console.log("%s %s %s", styleText("green", "●"), styleText(["greenBright", "underline"], client2.user.username), styleText("green", "application is ready!"));
-    await app.commands.register(client2);
-    await app.events.runReady(client2);
+  client.once("clientReady", async (client) => {
+    console.log("%s %s %s", styleText("green", "●"), styleText(["greenBright", "underline"], client.user.username), styleText("green", "application is ready!"));
+    await app.commands.register(client);
+    await app.events.runReady(client);
   });
   client.on("interactionCreate", async (interaction) => {
     if (interaction.isAutocomplete()) {

package/{dist → build}/creators/commands/command.d.ts

@@ -1,4 +1,4 @@
-import { ApplicationCommandOptionType, ApplicationCommandType, AutocompleteInteraction, ChatInputCommandInteraction, InteractionContextType, MessageContextMenuCommandInteraction, UserContextMenuCommandInteraction, type ApplicationCommandOptionAllowedChannelTypes, type ApplicationCommandOptionChoiceData, type BaseApplicationCommandData, type CacheType, type LocalizationMap } from "discord.js";
+import { ApplicationCommandOptionType, ApplicationCommandType, AutocompleteInteraction, ChatInputCommandInteraction, InteractionContextType, MessageContextMenuCommandInteraction, UserContextMenuCommandInteraction, type ApplicationCommandOptionAllowedChannelTypes, type ApplicationCommandOptionChoiceData, type BaseApplicationCommandData, type CacheType, type FileUploadType, type LocalizationMap } from "discord.js";
 import type { NotEmptyArray, UniqueArray } from "../../utils/types.js";
 export type CommandType = ApplicationCommandType.ChatInput | ApplicationCommandType.Message | ApplicationCommandType.User;
 type AutocompleData<Type> = Promise<readonly ApplicationCommandOptionChoiceData<Type extends (number | string) ? Type : (number | string)>[] | undefined | void>;
@@ -29,10 +29,14 @@ interface ChannelOptionData extends BaseOptionData {
     type: ApplicationCommandOptionType.Channel;
     channelTypes?: readonly ApplicationCommandOptionAllowedChannelTypes[];
 }
+interface AttachmentOptionData extends BaseOptionData {
+    type: ApplicationCommandOptionType.Attachment;
+    fileTypes?: readonly FileUploadType[];
+}
 interface CommonOptionData extends BaseOptionData {
-    type: ApplicationCommandOptionType.Attachment | ApplicationCommandOptionType.Boolean | ApplicationCommandOptionType.Mentionable | ApplicationCommandOptionType.Role | ApplicationCommandOptionType.User;
+    type: ApplicationCommandOptionType.Boolean | ApplicationCommandOptionType.Mentionable | ApplicationCommandOptionType.Role | ApplicationCommandOptionType.User;
 }
-export type SlashCommandPrimitiveOptionData<Contexts> = StringOptionData<Contexts> | NumberOptionData<Contexts> | CommonOptionData | ChannelOptionData;
+export type SlashCommandPrimitiveOptionData<Contexts> = StringOptionData<Contexts> | NumberOptionData<Contexts> | AttachmentOptionData | CommonOptionData | ChannelOptionData;
 export interface SubCommandOptionData<Contexts> extends Omit<BaseOptionData, "required"> {
     type: ApplicationCommandOptionType.Subcommand;
     options?: SlashCommandPrimitiveOptionData<Contexts>[];
@@ -52,15 +56,14 @@ interface CommandRunThis {
      */
     block(): never;
 }
-type ResolveCommandModuleData<Return> = Return extends void ? undefined : Return;
 export type SubCommandModuleData<Contexts, Return> = Omit<BaseOptionData, "required"> & {
     group?: string;
-    run(this: CommandRunThis, interaction: ChatInputCommandInteraction<CacheMode<Contexts>>, data: ResolveCommandModuleData<Return>): Promise<void>;
+    run(this: CommandRunThis, interaction: ChatInputCommandInteraction<CacheMode<Contexts>>, data: Return extends void ? undefined : Return): Promise<void>;
     options?: SlashCommandPrimitiveOptionData<Contexts>[];
 };
 export type SubCommandGroupModuleData<Contexts, Return, T> = Omit<BaseOptionData, "required"> & {
     options?: Omit<SubCommandOptionData<Contexts>, "type">[];
-    run?(this: CommandRunThis, interaction: ChatInputCommandInteraction<CacheMode<Contexts>>, data: ResolveCommandModuleData<Return>): Promise<T>;
+    run?(this: CommandRunThis, interaction: ChatInputCommandInteraction<CacheMode<Contexts>>, data: Return extends void ? undefined : Return): Promise<T>;
 };
 type RunInteraction<T, Contexts> = T extends ApplicationCommandType.Message ? MessageContextMenuCommandInteraction<CacheMode<Contexts>> : T extends ApplicationCommandType.User ? UserContextMenuCommandInteraction<CacheMode<Contexts>> : ChatInputCommandInteraction<CacheMode<Contexts>>;
 type BaseAppCommandData = Omit<BaseApplicationCommandData, "contexts"> & Pick<BaseOptionData, "descriptionLocalizations">;

package/{dist → build}/creators/commands/manager.js

@@ -81,12 +81,12 @@ class CommandManager extends BaseManager {
           continue;
         }
         case ApplicationCommandOptionType.Subcommand: {
-          const { options: options2, ...data } = option;
+          const { options, ...data } = option;
           resolved.push({
             ...data,
             description,
-            ...options2?.length ? {
-              options: this.buildOptions(options2, `${path}/${data.name}`)
+            ...options?.length ? {
+              options: this.buildOptions(options, `${path}/${data.name}`)
             } : {}
           });
           continue;
@@ -120,8 +120,8 @@ class CommandManager extends BaseManager {
     if (groups.length >= 1) {
       for (const group of groups) {
         const data = [
-          ...(group.options ?? []).map((data2) => ({
-            ...data2,
+          ...(group.options ?? []).map((data) => ({
+            ...data,
             type: ApplicationCommandOptionType.Subcommand
           })),
           ...subcommands.filter((sub) => sub.group === group.name)
@@ -197,8 +197,8 @@ class CommandManager extends BaseManager {
     const promises = [];
     const manager = client.application.commands;
     const logs = [];
-    const setGlobal = async (commands2) => {
-      const data = await manager.set(commands2);
+    const setGlobal = async (commands) => {
+      const data = await manager.set(commands);
       logs.push([data.size, `${client.user.username} application`]);
     };
     if (guildList.size) {

package/build/creators/index.d.ts

@@ -0,0 +1,6 @@
+export { ResponderType, type Responder, type ResponderData, type ResponderInteraction } from "./responders/responder.js";
+export { emitResponder, type EmitResponderData } from "./responders/emit.js";
+export type { GenericResponder, GenericResponderInteraction } from "./responders/manager.js";
+export type { Command, CommandData } from "./commands/command.js";
+export { type Event, type EventData, type EventPropData } from "./events/event.js";
+export * from "./setup.js";

package/{dist → build}/creators/index.js

@@ -6,6 +6,6 @@ import { emitResponder } from "./responders/emit.js";
 
 export * from "./setup.js";
 export {
-  emitResponder,
-  ResponderType
+  ResponderType,
+  emitResponder
 };

package/{dist → build}/creators/responders/emit.d.ts

@@ -3,7 +3,7 @@ export type WithCustomId<T> = T & {
     customId: string;
 };
 type EmitResponderInteraction = Omit<GenericResponderInteraction, "customId">;
-interface EmitResponderData {
+export interface EmitResponderData {
     customId: string;
     interaction: EmitResponderInteraction;
 }

package/build/creators/responders/responder.js

@@ -0,0 +1,26 @@
+// src/creators/responders/responder.ts
+var ResponderType;
+((ResponderType) => {
+  ResponderType["Button"] = "button";
+  ResponderType["StringSelect"] = "select.string";
+  ResponderType["UserSelect"] = "select.user";
+  ResponderType["RoleSelect"] = "select.role";
+  ResponderType["ChannelSelect"] = "select.channel";
+  ResponderType["MentionableSelect"] = "select.mentionable";
+  ResponderType["Modal"] = "modal";
+  ResponderType["ModalComponent"] = "modal.component";
+  ResponderType["ChatInput"] = "command.chat.input";
+  ResponderType["UserContextMenu"] = "command.context.user";
+  ResponderType["MessageContextMenu"] = "command.context.message";
+})(ResponderType ||= {});
+
+class Responder {
+  data;
+  constructor(data) {
+    this.data = data;
+  }
+}
+export {
+  Responder,
+  ResponderType
+};

package/{dist → build}/error.d.ts

@@ -1,6 +1,10 @@
 import { Client } from "discord.js";
 export declare class ConstaticError extends Error {
-    constructor(message: string);
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare class Errors {
+    static tokenNotProvided(): ConstaticError;
 }
 export declare class RunBlockError {
 }

package/{dist → build}/error.js

@@ -1,11 +1,19 @@
 // src/error.ts
-import { codeBlock, TextDisplayBuilder, time, parseWebhookURL, REST, Routes } from "discord.js";
+import { codeBlock, TextDisplayBuilder, time, WebhookClient } from "discord.js";
 import console from "node:console";
 import { styleText } from "node:util";
 
 class ConstaticError extends Error {
-  constructor(message) {
+  code;
+  constructor(code, message) {
     super(message);
+    this.code = code;
+  }
+}
+
+class Errors {
+  static tokenNotProvided() {
+    return new ConstaticError("TOKEN_NOT_PROVIDED", "The application token was not provided!");
   }
 }
 
@@ -15,7 +23,7 @@ async function baseErrorHandler(error, client) {
   if (client?.user)
     console.log(client.user.displayName);
   const text = [];
-  const hightlight = (text2) => text2.replace(/\(([^)]+)\)/g, (_, match) => [
+  const hightlight = (text) => text.replace(/\(([^)]+)\)/g, (_, match) => [
     styleText("gray", "("),
     styleText("cyan", match),
     styleText("gray", ")")
@@ -31,32 +39,24 @@ async function baseErrorHandler(error, client) {
   const url = process.env.WEBHOOK_LOGS_URL;
   if (!url)
     return;
-  const data = parseWebhookURL(url);
-  if (!data)
-    return;
-  const rest = new REST;
-  if (process.env.BOT_TOKEN)
-    rest.setToken(process.env.BOT_TOKEN);
+  const username = client?.user?.username;
   try {
-    const username = client?.user?.username;
-    rest.post(Routes.webhook(data.id, data.token), {
-      body: {
-        flags: ["IsComponentsV2"],
-        components: [
-          new TextDisplayBuilder({
-            content: [
-              codeBlock("ansi", text.join(`
+    new WebhookClient({ url }).send({
+      flags: "IsComponentsV2",
+      withComponents: true,
+      components: [
+        new TextDisplayBuilder({
+          content: [
+            codeBlock("ansi", text.join(`
 `)),
-              time(new Date, "R")
-            ].join(`
+            time(new Date, "R")
+          ].join(`
 `)
-          })
-        ],
-        withComponents: true,
-        avatarURL: client?.user?.displayAvatarURL({ size: 512 }),
-        username: username ? `${username} logs` : "Logs"
-      }
-    }).catch(console.error);
+        })
+      ],
+      avatarURL: client?.user?.displayAvatarURL({ size: 512 }),
+      username: username ? `${username} logs` : "Logs"
+    });
   } catch {
     console.log();
     console.error("ENV VAR → %s Invalid webhook url", styleText(["bold", "underline"], "WEBHOOK_LOGS_URL"));
@@ -65,7 +65,8 @@ async function baseErrorHandler(error, client) {
   }
 }
 export {
-  baseErrorHandler,
+  ConstaticError,
+  Errors,
   RunBlockError,
-  ConstaticError
+  baseErrorHandler
 };

package/{dist → build}/modules.d.ts

@@ -7,3 +7,4 @@ export interface ModuleImported {
  * along with its file path.
  */
 export declare function loadModules(meta: ImportMeta, modules?: string[]): Promise<ModuleImported[]>;
+export declare function generateImportsFile(meta: ImportMeta, path: string, imports: ModuleImported[]): Promise<void>;

package/build/modules.js

@@ -0,0 +1,34 @@
+// src/modules.ts
+import { glob, mkdir, writeFile } from "node:fs/promises";
+import { dirname, extname, join, relative } from "node:path";
+async function loadModules(meta, modules = []) {
+  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 loadedModules = [];
+  for (const path of filepaths) {
+    await import("file://" + join(meta.dirname, path)).then((imported) => loadedModules.push({
+      module: imported,
+      filepath: path
+    }));
+  }
+  return loadedModules;
+}
+async function generateImportsFile(meta, path, imports) {
+  const dir = dirname(path);
+  const content = imports.map(({ filepath }) => {
+    const modulePath = join(meta.dirname, filepath);
+    let relativePath = relative(dir, modulePath);
+    if (!relativePath.startsWith(".")) {
+      relativePath = `./${relativePath}`;
+    }
+    relativePath = relativePath.replaceAll("\\", "/").replace(new RegExp(`${extname(relativePath)}$`), ".js");
+    return `import "${relativePath}";`;
+  }).join(`
+`);
+  await mkdir(dir, { recursive: true });
+  await writeFile(path, content, "utf-8");
+}
+export {
+  generateImportsFile,
+  loadModules
+};

package/{dist → build}/version.js

@@ -1,5 +1,5 @@
 // src/version.ts
-var version = "0.0.10";
+var version = "0.1.2";
 export {
   version
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constatic/base",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Library with structures and functions for creating modern Discord applications.",
   "license": "MIT",
   "type": "module",
@@ -42,18 +42,18 @@
   },
   "devDependencies": {
     "@constatic/config": "*",
-    "typescript": "^5.8.2",
-    "discord.js": "^14.26.3"
+    "discord.js": "^14.28.1",
+    "typescript": "^7.0.2"
   },
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "import": "./build/index.js",
+      "types": "./build/index.d.ts"
     },
     "./tsconfig": "./tsconfig/base.json"
   },
   "files": [
-    "dist",
+    "build",
     "tsconfig"
   ],
   "homepage": "https://constatic-docs.vercel.app",
@@ -63,17 +63,15 @@
     ]
   },
   "scripts": {
-    "check": "tsc --noEmit",
     "typegen": "tsc",
     "build": "bun run ./build.ts",
     "prepublish": "bun run build",
-    "dev": "bun run ./playground/index.ts"
+    "dev": "bun run ./demo/index.ts"
   },
   "peerDependencies": {
     "discord.js": ">=14.25.0"
   },
   "dependencies": {
-    "rou3": "^0.8.1",
-    "tinyglobby": "^0.2.16"
+    "rou3": "^1.0.0"
   }
 }

package/tsconfig/base.json

@@ -1,11 +1,12 @@
 {
     "$schema": "https://www.schemastore.org/tsconfig",
 	"compilerOptions": {
+		"strict": true,
+		"verbatimModuleSyntax": true,
 		"esModuleInterop": true,
 		"forceConsistentCasingInFileNames": true,
 		"skipLibCheck": true,
 		"resolveJsonModule": true,
-		"strict": true,
         
 		"lib": ["ESNext"],
 		"target": "ESNext",

package/dist/creators/index.d.ts

@@ -1,5 +0,0 @@
-export { ResponderType, type Responder, type ResponderData, type ResponderInteraction } from "./responders/responder.js";
-export { emitResponder } from "./responders/emit.js";
-export { type Command, type CommandData } from "./commands/command.js";
-export { type Event, type EventData, type EventPropData } from "./events/event.js";
-export * from "./setup.js";

package/dist/creators/responders/responder.js

@@ -1,26 +0,0 @@
-// src/creators/responders/responder.ts
-var ResponderType;
-((ResponderType2) => {
-  ResponderType2["Button"] = "button";
-  ResponderType2["StringSelect"] = "select.string";
-  ResponderType2["UserSelect"] = "select.user";
-  ResponderType2["RoleSelect"] = "select.role";
-  ResponderType2["ChannelSelect"] = "select.channel";
-  ResponderType2["MentionableSelect"] = "select.mentionable";
-  ResponderType2["Modal"] = "modal";
-  ResponderType2["ModalComponent"] = "modal.component";
-  ResponderType2["ChatInput"] = "command.chat.input";
-  ResponderType2["UserContextMenu"] = "command.context.user";
-  ResponderType2["MessageContextMenu"] = "command.context.message";
-})(ResponderType ||= {});
-
-class Responder {
-  data;
-  constructor(data) {
-    this.data = data;
-  }
-}
-export {
-  ResponderType,
-  Responder
-};

package/dist/modules.js

@@ -1,18 +0,0 @@
-// src/modules.ts
-import { join } from "node:path";
-import { glob } from "tinyglobby";
-async function loadModules(meta, modules = []) {
-  const ignore = modules.filter((path) => path.charAt(0) == "!").map((path) => path.slice(1));
-  const filepaths = await glob(modules, { cwd: meta.dirname, ignore });
-  const loadedModules = [];
-  for (const path of filepaths) {
-    await import("file://" + join(meta.dirname, path)).then((imported) => loadedModules.push({
-      module: imported,
-      filepath: path
-    }));
-  }
-  return loadedModules;
-}
-export {
-  loadModules
-};

package/dist/register.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/register.js

@@ -1,21 +0,0 @@
-// src/register.ts
-import { ConstaticApp } from "./app.js";
-async function registerCommands(client) {
-  const app = ConstaticApp.getInstance();
-  const guildList = new Set(app.config.commands.guilds);
-  const commands = app.commands.build();
-  const promises = [];
-  const manager = client.application.commands;
-  if (guildList.size >= 1) {
-    const globalCommands = commands.filter((c) => c.global);
-    const guildCommands = commands.filter((c) => !c.global);
-    for (const id of guildList.values()) {
-      promises.push(manager.set(guildCommands, id));
-    }
-    promises.push(manager.set(globalCommands));
-  }
-  await Promise.all(promises).then(console.log);
-}
-export {
-  registerCommands
-};

package/dist/utils/schema.d.ts

@@ -1,56 +0,0 @@
-/** The Standard Schema interface. */
-export interface StandardSchemaV1<Input = unknown, Output = Input> {
-    /** The Standard Schema properties. */
-    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
-}
-export declare namespace StandardSchemaV1 {
-    /** The Standard Schema properties interface. */
-    export interface Props<Input = unknown, Output = Input> {
-        /** The version number of the standard. */
-        readonly version: 1;
-        /** The vendor name of the schema library. */
-        readonly vendor: string;
-        /** Validates unknown input values. */
-        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
-        /** Inferred types associated with the schema. */
-        readonly types?: Types<Input, Output> | undefined;
-    }
-    /** The result interface of the validate function. */
-    export type Result<Output> = SuccessResult<Output> | FailureResult;
-    /** The result interface if validation succeeds. */
-    export interface SuccessResult<Output> {
-        /** The typed output value. */
-        readonly value: Output;
-        /** The non-existent issues. */
-        readonly issues?: undefined;
-    }
-    /** The result interface if validation fails. */
-    export interface FailureResult {
-        /** The issues of failed validation. */
-        readonly issues: ReadonlyArray<Issue>;
-    }
-    /** The issue interface of the failure output. */
-    export interface Issue {
-        /** The error message of the issue. */
-        readonly message: string;
-        /** The path of the issue, if any. */
-        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
-    }
-    /** The path segment interface of the issue. */
-    export interface PathSegment {
-        /** The key representing a path segment. */
-        readonly key: PropertyKey;
-    }
-    /** The Standard Schema types interface. */
-    export interface Types<Input = unknown, Output = Input> {
-        /** The input type of the schema. */
-        readonly input: Input;
-        /** The output type of the schema. */
-        readonly output: Output;
-    }
-    /** Infers the input type of a Standard Schema. */
-    export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
-    /** Infers the output type of a Standard Schema. */
-    export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
-    export {};
-}