@ezzi/base 1.0.0

package/dist/tools/parseCommand.js

@@ -0,0 +1,144 @@
+// src/tools/parseCommand.ts
+import {
+  ApplicationCommandOptionType
+} from "discord.js";
+import { EzziApp } from "../app.js";
+import {
+  IgnoreCommand
+} from "../creators/commands/command.js";
+var optionTypes = {
+  3: "string",
+  4: "integer",
+  5: "boolean",
+  6: "user",
+  7: "channel",
+  8: "role",
+  9: "mention",
+  10: "number",
+  11: "file"
+};
+function sanitizeLocalizations(localizations) {
+  if (!localizations)
+    return;
+  const sanitized = {};
+  for (const [locale, translation] of Object.entries(localizations)) {
+    if (translation === null) {
+      sanitized[locale] = null;
+      continue;
+    }
+    sanitized[locale] = translation;
+  }
+  return sanitized;
+}
+function parseCommands(client) {
+  const discordCommands = client.application?.commands.cache;
+  const app = EzziApp.getInstance();
+  const localCommands = app.commands["collection"];
+  if (!localCommands)
+    return [];
+  const parsedList = [];
+  for (const [_, localCmd] of localCommands) {
+    const discordCmd = discordCommands?.find((c) => c.name === localCmd.name);
+    const isRootSlashIgnored = localCmd.ignore === IgnoreCommand.Slash;
+    if (!discordCmd && !isRootSlashIgnored)
+      continue;
+    const id = discordCmd?.id ?? null;
+    const category = localCmd.category || "Utils";
+    const cmdAliases = localCmd.aliases;
+    if (!localCmd.modules || localCmd.modules.length === 0) {
+      parsedList.push({
+        id,
+        name: localCmd.name,
+        description: localCmd.description || "",
+        category,
+        options: formatOptions(localCmd.options || []),
+        slash: isRootSlashIgnored || !id ? null : { id, name: localCmd.name },
+        localizations: sanitizeLocalizations(localCmd.descriptionLocalizations),
+        aliases: cmdAliases
+      });
+      continue;
+    }
+    if (localCmd.modules) {
+      const subcommands = localCmd.modules.filter((m) => m.type === ApplicationCommandOptionType.Subcommand && !m.group);
+      const groups = localCmd.modules.filter((m) => m.type === ApplicationCommandOptionType.SubcommandGroup);
+      for (const localSub of subcommands) {
+        const isSlashIgnored = localSub.ignore === IgnoreCommand.Slash;
+        const isMessageIgnored = localSub.ignore === IgnoreCommand.Message;
+        const fullAliases = [];
+        if (!isMessageIgnored) {
+          const cmdNames = [localCmd.name, ...cmdAliases ?? []];
+          const subNames = [localSub.name, ...localSub.aliases ?? []];
+          for (const c of cmdNames) {
+            for (const s of subNames) {
+              if (c === localCmd.name && s === localSub.name)
+                continue;
+              fullAliases.push(`${c} ${s}`);
+            }
+          }
+          if (localSub.shortcut) {
+            fullAliases.push(localSub.name, ...localSub.aliases ?? []);
+          }
+        }
+        parsedList.push({
+          id,
+          name: `${localCmd.name} ${localSub.name}`,
+          description: localSub.description || "",
+          category,
+          options: formatOptions(localSub.options || []),
+          slash: isSlashIgnored || !id ? null : { id, name: `${localCmd.name} ${localSub.name}` },
+          localizations: sanitizeLocalizations(localSub.descriptionLocalizations),
+          aliases: isMessageIgnored ? [] : fullAliases.length ? fullAliases : undefined
+        });
+      }
+      for (const localGroup of groups) {
+        const groupSubs = localCmd.modules.filter((m) => m.type === ApplicationCommandOptionType.Subcommand && m.group === localGroup.name);
+        for (const localSub of groupSubs) {
+          const isSlashIgnored = localSub.ignore === IgnoreCommand.Slash;
+          const isMessageIgnored = localSub.ignore === IgnoreCommand.Message;
+          const fullAliases = [];
+          if (!isMessageIgnored) {
+            const cmdNames = [localCmd.name, ...cmdAliases ?? []];
+            const groupNames = [localGroup.name, ...localGroup.aliases ?? []];
+            const subNames = [localSub.name, ...localSub.aliases ?? []];
+            for (const c of cmdNames) {
+              for (const g of groupNames) {
+                for (const s of subNames) {
+                  if (c === localCmd.name && g === localGroup.name && s === localSub.name)
+                    continue;
+                  fullAliases.push(`${c} ${g} ${s}`);
+                }
+              }
+            }
+            if (localSub.shortcut) {
+              fullAliases.push(localSub.name, ...localSub.aliases ?? []);
+            }
+          }
+          parsedList.push({
+            id,
+            name: `${localCmd.name} ${localGroup.name} ${localSub.name}`,
+            description: localSub.description || "",
+            category,
+            options: formatOptions(localSub.options || []),
+            slash: isSlashIgnored || !id ? null : {
+              id,
+              name: `${localCmd.name} ${localGroup.name} ${localSub.name}`
+            },
+            localizations: sanitizeLocalizations(localSub.descriptionLocalizations),
+            aliases: isMessageIgnored ? [] : fullAliases.length ? fullAliases : undefined
+          });
+        }
+      }
+    }
+  }
+  return parsedList;
+}
+function formatOptions(options) {
+  return options.filter((opt) => opt.type !== ApplicationCommandOptionType.Subcommand && opt.type !== ApplicationCommandOptionType.SubcommandGroup).map((opt) => {
+    const typeName = optionTypes[opt.type] || "any";
+    const formatted = `${opt.name}: ${typeName}`;
+    return opt.required ? `<${formatted}>` : `[${formatted}]`;
+  }).join(", ");
+}
+export {
+  parseCommands
+};

package/dist/utils/router.d.ts

@@ -0,0 +1,9 @@
+import { type MatchedRoute } from "rou3";
+export declare class Router<T> {
+    private router;
+    constructor();
+    add(method: string, path: string, data?: T): void;
+    find(method: string, path: string): MatchedRoute<T> | undefined;
+    remove(method: string, path: string): void;
+    private resolvePath;
+}

package/dist/utils/router.js

@@ -0,0 +1,24 @@
+// src/utils/router.ts
+import { addRoute, createRouter, findRoute, removeRoute } from "rou3";
+
+class Router {
+  router;
+  constructor() {
+    this.router = createRouter();
+  }
+  add(method, path, data) {
+    addRoute(this.router, method.toUpperCase(), this.resolvePath(path), data);
+  }
+  find(method, path) {
+    return findRoute(this.router, method.toUpperCase(), this.resolvePath(path));
+  }
+  remove(method, path) {
+    removeRoute(this.router, method.toUpperCase(), this.resolvePath(path));
+  }
+  resolvePath(path) {
+    return path.startsWith("/") ? path : `/${path}`;
+  }
+}
+export {
+  Router
+};

package/dist/utils/types.d.ts

@@ -0,0 +1,7 @@
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type NotEmptyArray<T> = T extends never[] ? never : T;
+export type UniqueArray<T> = T extends readonly [infer X, ...infer Rest] ? InArray<Rest, X> extends true ? ["Encountered value with duplicates:", X] : readonly [X, ...UniqueArray<Rest>] : T;
+type InArray<T, X> = T extends readonly [X, ...infer _Rest] ? true : T extends readonly [X] ? true : T extends readonly [infer _, ...infer Rest] ? InArray<Rest, X> : false;
+export {};

package/dist/version.d.ts

@@ -0,0 +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

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

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@ezzi/base",
+  "version": "1.0.0",
+  "description": "Library with structures and functions for creating modern Discord applications.",
+  "license": "MIT",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "modern",
+    "base",
+    "discord",
+    "bot",
+    "discord bot",
+    "discord app",
+    "discord application",
+    "discord api",
+    "discord.js",
+    "typescript",
+    "app",
+    "api",
+    "tools",
+    "router",
+    "handlers",
+    "managers",
+    "loaders",
+    "modules",
+    "development",
+    "es6",
+    "node",
+    "bun"
+  ],
+  "repository": {
+    "url": "https://github.com/eufelipw0/ezzi",
+    "type": "git",
+    "directory": "packages/core"
+  },
+  "author": {
+    "name": "eufelipw0",
+    "url": "https://github.com/eufelipw0"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./tsconfig": "./tsconfig/base.json"
+  },
+  "files": [
+    "dist",
+    "tsconfig"
+  ],
+  "imports": {
+    "#package": [
+      "./src/index.ts"
+    ]
+  },
+  "scripts": {
+    "check": "tsc --noEmit",
+    "typegen": "tsc",
+    "build": "bun run ./build.ts",
+    "prepublish": "bun run build",
+    "dev": "bun run ./playground/index.ts"
+  },
+  "dependencies": {
+    "@magicyan/discord": "1.5.1",
+    "chalk": "5.4.1",
+    "rou3": "^0.8.1",
+    "tinyglobby": "^0.2.16"
+  },
+  "peerDependencies": {
+    "discord.js": ">=14.25.0"
+  },
+  "devDependencies": {
+    "@ezzi/config": "*",
+    "typescript": "^5.8.2"
+  }
+}

package/tsconfig/base.json

@@ -0,0 +1,21 @@
+{
+    "$schema": "https://www.schemastore.org/tsconfig",
+	"compilerOptions": {
+		"esModuleInterop": true,
+		"forceConsistentCasingInFileNames": true,
+		"skipLibCheck": true,
+		"resolveJsonModule": true,
+		"strict": true,
+        
+		"lib": ["ESNext"],
+		"target": "ESNext",
+		"module": "NodeNext",
+		"moduleResolution": "NodeNext",
+		
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"noImplicitReturns": true,
+		"noImplicitOverride": true,
+		"noEmitOnError": true,
+	}
+}