commandkit 1.2.1 → 1.2.2

package/dist/app/router/CommandsRouter.js

@@ -1,11 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_chunk = require('../../chunk-BE-pF4vm.js');
 let discord_js = require("discord.js");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
 let node_fs_promises = require("node:fs/promises");
 
 //#region src/app/router/CommandsRouter.ts
+const ROOT_NODE_ID = "__commandkit_router_root__";
 /**
 * @private
 * @internal
@@ -32,9 +32,35 @@ const COMMAND_PATTERN = /^([^+().][^().]*)\.(m|c)?(j|t)sx?$/;
 */
 const CATEGORY_PATTERN = /^\(.+\)$/;
 /**
+* @private
+* @internal
+*/
+const COMMAND_DIRECTORY_PATTERN = /^\[([^\][\\\/]+)\]$/;
+/**
+* @private
+* @internal
+*/
+const GROUP_DIRECTORY_PATTERN = /^\{([^}{\\\/]+)\}$/;
+/**
+* @private
+* @internal
+*/
+const COMMAND_DEFINITION_PATTERN = /^command\.(m|c)?(j|t)sx?$/;
+/**
+* @private
+* @internal
+*/
+const GROUP_DEFINITION_PATTERN = /^group\.(m|c)?(j|t)sx?$/;
+/**
+* @private
+* @internal
+*/
+const SUBCOMMAND_FILE_PATTERN = /^([^+().][^().]*)\.subcommand\.(m|c)?(j|t)sx?$/;
+/**
 * Handles discovery and parsing of command and middleware files in the filesystem.
 */
 var CommandsRouter = class {
+	options;
 	/**
 	* @private
 	* @internal
@@ -46,6 +72,21 @@ var CommandsRouter = class {
 	*/
 	middlewares = new discord_js.Collection();
 	/**
+	* @private
+	* @internal
+	*/
+	treeNodes = new discord_js.Collection();
+	/**
+	* @private
+	* @internal
+	*/
+	compiledRoutes = new discord_js.Collection();
+	/**
+	* @private
+	* @internal
+	*/
+	diagnostics = [];
+	/**
 	* Creates a new CommandsRouter instance.
 	* @param options - Configuration options for the router
 	*/
@@ -53,12 +94,16 @@ var CommandsRouter = class {
 		this.options = options;
 	}
 	/**
-	* Populates the router with existing command and middleware data.
+	* Populates the router with existing command, middleware, and tree data.
 	* @param data - Parsed command data to populate with
 	*/
 	populate(data) {
+		this.clear();
 		for (const [id, command] of Object.entries(data.commands)) this.commands.set(id, command);
 		for (const [id, middleware] of Object.entries(data.middlewares)) this.middlewares.set(id, middleware);
+		for (const [id, node] of Object.entries(data.treeNodes ?? {})) this.treeNodes.set(id, node);
+		for (const [key, route] of Object.entries(data.compiledRoutes ?? {})) this.compiledRoutes.set(key, route);
+		this.diagnostics = [...data.diagnostics ?? []];
 	}
 	/**
 	* Checks if the configured entrypoint path exists.
@@ -89,64 +134,425 @@ var CommandsRouter = class {
 		return CATEGORY_PATTERN.test(name);
 	}
 	/**
-	* Clears all loaded commands and middleware.
+	* @private
+	* @internal
+	*/
+	isCommandDirectory(name) {
+		return COMMAND_DIRECTORY_PATTERN.test(name);
+	}
+	/**
+	* @private
+	* @internal
+	*/
+	isGroupDirectory(name) {
+		return GROUP_DIRECTORY_PATTERN.test(name);
+	}
+	/**
+	* @private
+	* @internal
+	*/
+	isCommandDefinition(name) {
+		return COMMAND_DEFINITION_PATTERN.test(name);
+	}
+	/**
+	* @private
+	* @internal
+	*/
+	isGroupDefinition(name) {
+		return GROUP_DEFINITION_PATTERN.test(name);
+	}
+	/**
+	* @private
+	* @internal
+	*/
+	isSubcommandFile(name) {
+		return SUBCOMMAND_FILE_PATTERN.test(name);
+	}
+	/**
+	* Clears all loaded commands, middleware, and compiled tree data.
 	*/
 	clear() {
 		this.commands.clear();
 		this.middlewares.clear();
+		this.treeNodes.clear();
+		this.compiledRoutes.clear();
+		this.diagnostics = [];
 	}
 	/**
 	* Scans the filesystem for commands and middleware files.
 	* @returns Parsed command data
 	*/
 	async scan() {
-		const entries = await (0, node_fs_promises.readdir)(this.options.entrypoint, { withFileTypes: true });
-		for (const entry of entries) {
-			if (entry.name.startsWith("_")) continue;
-			const fullPath = (0, node_path.join)(this.options.entrypoint, entry.name);
-			if (entry.isDirectory()) {
-				const category = this.isCategory(entry.name) ? entry.name.slice(1, -1) : null;
-				await this.traverse(fullPath, category);
-			} else await this.handle(entry);
-		}
+		this.clear();
+		this.initializeRootNode();
+		await this.traverseDirectory(this.options.entrypoint, "normal", null, ROOT_NODE_ID);
 		await this.applyMiddlewares();
+		this.compileTree();
 		return this.toJSON();
 	}
 	/**
-	* Gets the raw command and middleware collections.
-	* @returns Object containing commands and middlewares collections
+	* Incrementally updates only the top-level command subtree affected by a file change.
+	* Falls back to a full scan when the changed path cannot be safely scoped.
+	*/
+	async scanIncremental(changedPath, _changeType = "change") {
+		var _topLevelToken$match;
+		const normalizedPath = (0, node_path.normalize)(changedPath);
+		if (!this.isWithinPath(this.options.entrypoint, normalizedPath)) return this.toJSON();
+		const relativePath = this.replaceEntrypoint(normalizedPath).replace(/^[/\\]/, "").split(/[/\\]/).filter(Boolean);
+		if (!relativePath.length) return this.scan();
+		const topLevelToken = relativePath[0];
+		if (!this.isCommandDirectory(topLevelToken)) return this.scan();
+		const commandName = (_topLevelToken$match = topLevelToken.match(COMMAND_DIRECTORY_PATTERN)) === null || _topLevelToken$match === void 0 ? void 0 : _topLevelToken$match[1];
+		if (!commandName) return this.scan();
+		this.ensureRootNode();
+		const commandRootDirectory = (0, node_path.join)(this.options.entrypoint, topLevelToken);
+		this.pruneCommandSubtree(commandName, commandRootDirectory);
+		if ((0, node_fs.existsSync)(commandRootDirectory)) await this.traverseDirectory(commandRootDirectory, "command", null, ROOT_NODE_ID, commandName);
+		await this.applyMiddlewares();
+		this.compileTree();
+		return this.toJSON();
+	}
+	/**
+	* Gets the raw command, middleware, and compiled tree collections.
+	* @returns Object containing router collections
 	*/
 	getData() {
 		return {
 			commands: this.commands,
-			middlewares: this.middlewares
+			middlewares: this.middlewares,
+			treeNodes: this.treeNodes,
+			compiledRoutes: this.compiledRoutes,
+			diagnostics: this.diagnostics
+		};
+	}
+	/**
+	* Gets only the internal command tree and compiled route data.
+	* @returns Object containing tree data
+	*/
+	getTreeData() {
+		return {
+			treeNodes: this.treeNodes,
+			compiledRoutes: this.compiledRoutes,
+			diagnostics: this.diagnostics
 		};
 	}
 	/**
 	* Converts the loaded data to a JSON-serializable format.
-	* @returns Plain object with commands and middlewares
+	* @returns Plain object with commands, middleware, and tree data
 	*/
 	toJSON() {
 		return {
 			commands: Object.fromEntries(this.commands.entries()),
-			middlewares: Object.fromEntries(this.middlewares.entries())
+			middlewares: Object.fromEntries(this.middlewares.entries()),
+			treeNodes: Object.fromEntries(this.treeNodes.entries()),
+			compiledRoutes: Object.fromEntries(this.compiledRoutes.entries()),
+			diagnostics: this.diagnostics
 		};
 	}
 	/**
 	* @private
 	* @internal
 	*/
-	async traverse(path, category) {
+	initializeRootNode() {
+		this.treeNodes.set(ROOT_NODE_ID, {
+			id: ROOT_NODE_ID,
+			source: "root",
+			kind: "root",
+			token: "",
+			route: [],
+			category: null,
+			parentId: null,
+			childIds: [],
+			directoryPath: this.options.entrypoint,
+			definitionPath: null,
+			relativePath: "",
+			shorthand: false,
+			executable: false
+		});
+	}
+	/**
+	* @private
+	* @internal
+	*/
+	ensureRootNode() {
+		if (!this.treeNodes.has(ROOT_NODE_ID)) this.initializeRootNode();
+	}
+	/**
+	* @private
+	* @internal
+	*/
+	pruneCommandSubtree(commandName, commandRootDirectory) {
+		const normalizedRootDirectory = (0, node_path.normalize)(commandRootDirectory);
+		for (const [id, command] of this.commands.entries()) if (command.name === commandName || this.isWithinPath(normalizedRootDirectory, command.path) || this.isWithinPath(normalizedRootDirectory, command.parentPath)) this.commands.delete(id);
+		for (const [id, middleware] of this.middlewares.entries()) if (this.isWithinPath(normalizedRootDirectory, middleware.path) || this.isWithinPath(normalizedRootDirectory, middleware.parentPath)) this.middlewares.delete(id);
+		const nodeIdsToDelete = /* @__PURE__ */ new Set();
+		for (const [id, node] of this.treeNodes.entries()) {
+			if (id === ROOT_NODE_ID) continue;
+			if (node.route[0] === commandName || this.isWithinPath(normalizedRootDirectory, node.directoryPath) || node.definitionPath && this.isWithinPath(normalizedRootDirectory, node.definitionPath)) nodeIdsToDelete.add(id);
+		}
+		if (nodeIdsToDelete.size) {
+			for (const id of nodeIdsToDelete) this.treeNodes.delete(id);
+			for (const node of this.treeNodes.values()) node.childIds = node.childIds.filter((childId) => {
+				return !nodeIdsToDelete.has(childId);
+			});
+		}
+	}
+	/**
+	* @private
+	* @internal
+	*/
+	async traverseDirectory(path, state, category, parentId, token) {
+		let node = null;
+		if (state === "command") {
+			node = this.createTreeNode({
+				source: "directory",
+				token,
+				category,
+				parentId,
+				directoryPath: path,
+				definitionPath: null,
+				shorthand: false
+			});
+			if (!node) return;
+		} else if (state === "group") {
+			node = this.createTreeNode({
+				source: "group",
+				token,
+				category,
+				parentId,
+				directoryPath: path,
+				definitionPath: null,
+				shorthand: false
+			});
+			if (!node) return;
+		}
+		const currentNodeId = node ? node.id : parentId;
 		const entries = await (0, node_fs_promises.readdir)(path, { withFileTypes: true });
 		for (const entry of entries) {
 			if (entry.name.startsWith("_")) continue;
+			const fullPath = (0, node_path.join)(path, entry.name);
 			if (entry.isFile()) {
-				if (this.isCommand(entry.name) || this.isMiddleware(entry.name)) await this.handle(entry, category);
-			} else if (entry.isDirectory() && this.isCategory(entry.name) && category) {
-				const nestedCategory = this.isCategory(entry.name) ? `${category}:${entry.name.slice(1, -1)}` : null;
-				await this.traverse((0, node_path.join)(path, entry.name), nestedCategory);
+				if (state === "command") {
+					if (this.isCommandDefinition(entry.name)) {
+						node.definitionPath = fullPath;
+						node.relativePath = this.replaceEntrypoint(fullPath);
+						continue;
+					}
+					if (this.isSubcommandFile(entry.name)) {
+						this.createTreeNode({
+							source: "shorthand",
+							token: entry.name.match(SUBCOMMAND_FILE_PATTERN)[1],
+							category,
+							parentId: currentNodeId,
+							directoryPath: path,
+							definitionPath: fullPath,
+							shorthand: true
+						});
+						continue;
+					}
+					if (this.isMiddleware(entry.name)) {
+						await this.handle(entry, category);
+						continue;
+					}
+					if (this.isCommand(entry.name)) this.addDiagnostic("UNSUPPORTED_FILE_IN_COMMAND_DIRECTORY", "Only command.ts, middleware files, and subcommand shorthand files are supported inside a command directory.", fullPath);
+				} else if (state === "group") {
+					if (this.isGroupDefinition(entry.name)) {
+						node.definitionPath = fullPath;
+						node.relativePath = this.replaceEntrypoint(fullPath);
+						continue;
+					}
+					if (this.isSubcommandFile(entry.name)) {
+						this.createTreeNode({
+							source: "shorthand",
+							token: entry.name.match(SUBCOMMAND_FILE_PATTERN)[1],
+							category,
+							parentId: currentNodeId,
+							directoryPath: path,
+							definitionPath: fullPath,
+							shorthand: true
+						});
+						continue;
+					}
+					if (this.isMiddleware(entry.name)) {
+						await this.handle(entry, category);
+						continue;
+					}
+					if (this.isCommand(entry.name)) this.addDiagnostic("UNSUPPORTED_FILE_IN_GROUP_DIRECTORY", "Only group.ts, middleware files, and subcommand shorthand files are supported inside a group directory.", fullPath);
+				} else {
+					if (this.isSubcommandFile(entry.name)) {
+						if (currentNodeId === ROOT_NODE_ID) this.addDiagnostic("ORPHAN_SUBCOMMAND_FILE", "Subcommand shorthand files must be nested inside a command or group directory.", fullPath);
+						else this.createTreeNode({
+							source: "shorthand",
+							token: entry.name.match(SUBCOMMAND_FILE_PATTERN)[1],
+							category,
+							parentId: currentNodeId,
+							directoryPath: path,
+							definitionPath: fullPath,
+							shorthand: true
+						});
+						continue;
+					}
+					if (this.isCommand(entry.name) || this.isMiddleware(entry.name)) {
+						const result = await this.handle(entry, category);
+						if (result.command) this.createFlatCommandNode(result.command);
+					}
+				}
+				continue;
+			}
+			if (!entry.isDirectory()) continue;
+			if (this.isCommandDirectory(entry.name)) {
+				if (state === "command" || state === "group") await this.traverseDirectory(fullPath, "command", category, currentNodeId, entry.name.match(COMMAND_DIRECTORY_PATTERN)[1]);
+				else if (currentNodeId !== ROOT_NODE_ID) this.addDiagnostic("NESTED_COMMAND_NOT_ALLOWED", "Command directories cannot be nested under group or subcommand directories unless they are part of a hierarchical structure.", fullPath);
+				else await this.traverseDirectory(fullPath, "command", category, ROOT_NODE_ID, entry.name.match(COMMAND_DIRECTORY_PATTERN)[1]);
+				continue;
 			}
+			if (this.isGroupDirectory(entry.name)) {
+				if (currentNodeId === ROOT_NODE_ID) this.addDiagnostic("ROOT_GROUP_NOT_ALLOWED", "Group directories must be nested inside a command directory.", fullPath);
+				else await this.traverseDirectory(fullPath, "group", category, currentNodeId, entry.name.match(GROUP_DIRECTORY_PATTERN)[1]);
+				continue;
+			}
+			if (this.isCategory(entry.name)) {
+				const nestedCategory = category ? `${category}:${entry.name.slice(1, -1)}` : entry.name.slice(1, -1);
+				await this.traverseDirectory(fullPath, "normal", nestedCategory, currentNodeId);
+				continue;
+			}
+			await this.traverseDirectory(fullPath, "normal", category, currentNodeId);
 		}
+		if (state === "command" && node && !node.definitionPath) this.addDiagnostic("MISSING_COMMAND_DEFINITION", "Command directories must include a command.ts file.", path);
+		else if (state === "group" && node && !node.definitionPath) this.addDiagnostic("MISSING_GROUP_DEFINITION", "Group directories must include a group.ts file.", path);
+	}
+	/**
+	* @private
+	* @internal
+	*/
+	createFlatCommandNode(command) {
+		this.createTreeNode({
+			id: command.id,
+			source: "flat",
+			token: command.name,
+			category: command.category,
+			parentId: ROOT_NODE_ID,
+			directoryPath: command.parentPath,
+			definitionPath: command.path,
+			shorthand: false
+		});
+	}
+	/**
+	* @private
+	* @internal
+	*/
+	createTreeNode(options) {
+		const parent = this.treeNodes.get(options.parentId);
+		if (!parent) {
+			this.addDiagnostic("MISSING_PARENT_NODE", `Unable to create command tree node "${options.token}" because its parent node was not found.`, options.directoryPath);
+			return null;
+		}
+		if (parent.childIds.some((childId) => {
+			var _this$treeNodes$get;
+			return ((_this$treeNodes$get = this.treeNodes.get(childId)) === null || _this$treeNodes$get === void 0 ? void 0 : _this$treeNodes$get.token) === options.token;
+		})) {
+			this.addDiagnostic("DUPLICATE_SIBLING_TOKEN", `Duplicate command token "${options.token}" found under the same parent.`, options.definitionPath ?? options.directoryPath);
+			return null;
+		}
+		const route = [...parent.route, options.token];
+		const node = {
+			id: options.id ?? crypto.randomUUID(),
+			source: options.source,
+			kind: this.resolveNodeKind(options.source, route.length),
+			token: options.token,
+			route,
+			category: options.category,
+			parentId: options.parentId,
+			childIds: [],
+			directoryPath: options.directoryPath,
+			definitionPath: options.definitionPath,
+			relativePath: this.replaceEntrypoint(options.definitionPath ?? options.directoryPath),
+			shorthand: options.shorthand,
+			executable: false
+		};
+		this.treeNodes.set(node.id, node);
+		parent.childIds.push(node.id);
+		return node;
+	}
+	/**
+	* @private
+	* @internal
+	*/
+	resolveNodeKind(source, depth) {
+		switch (source) {
+			case "root": return "root";
+			case "flat": return "flat";
+			case "group": return "group";
+			case "shorthand": return "subcommand";
+			case "directory": return depth === 1 ? "command" : "subcommand";
+			default: return source;
+		}
+	}
+	/**
+	* @private
+	* @internal
+	*/
+	compileTree() {
+		this.compiledRoutes.clear();
+		for (const node of this.treeNodes.values()) {
+			if (node.id === ROOT_NODE_ID) continue;
+			const hasChildren = node.childIds.length > 0;
+			node.executable = !!node.definitionPath && node.kind !== "group" && !hasChildren;
+			if (hasChildren && node.definitionPath && node.kind !== "group") this.addDiagnostic("NON_LEAF_NODE_MAY_HAVE_HANDLERS", `Hierarchical node "${node.route.join(".")}" has child nodes. Ensure its command.ts file does not export chatInput, message, or autocomplete handlers. Executable handlers must be defined on leaf nodes.`, node.definitionPath);
+			if (node.kind === "subcommand" && hasChildren) this.addDiagnostic("SUBCOMMAND_CANNOT_HAVE_CHILDREN", `Subcommand "${node.route.join(".")}" cannot contain child command nodes.`, node.definitionPath ?? node.directoryPath);
+			if (node.kind === "command") {
+				const childKinds = new Set(node.childIds.map((childId) => {
+					var _this$treeNodes$get2;
+					return (_this$treeNodes$get2 = this.treeNodes.get(childId)) === null || _this$treeNodes$get2 === void 0 ? void 0 : _this$treeNodes$get2.kind;
+				}).filter(Boolean));
+				if (childKinds.has("group") && childKinds.has("subcommand")) this.addDiagnostic("MIXED_ROOT_CHILDREN", `Command "${node.route.join(".")}" cannot mix direct subcommands and subcommand groups.`, node.definitionPath ?? node.directoryPath);
+			}
+			if (!node.executable || !node.definitionPath) continue;
+			const key = node.route.join(".");
+			const routeKind = node.kind;
+			this.compiledRoutes.set(key, {
+				id: node.id,
+				key,
+				kind: routeKind,
+				token: node.token,
+				route: node.route,
+				category: node.category,
+				definitionPath: node.definitionPath,
+				relativePath: this.replaceEntrypoint(node.definitionPath),
+				nodeId: node.id,
+				middlewares: this.collectCompiledMiddlewares(node)
+			});
+		}
+	}
+	/**
+	* @private
+	* @internal
+	*/
+	collectCompiledMiddlewares(node) {
+		const allMiddlewares = Array.from(this.middlewares.values());
+		const globalMiddlewares = allMiddlewares.filter((middleware) => middleware.global).map((middleware) => middleware.id);
+		const directoryMiddlewares = allMiddlewares.filter((middleware) => {
+			return !middleware.global && !middleware.command && middleware.parentPath === node.directoryPath;
+		}).map((middleware) => middleware.id);
+		const commandSpecificMiddlewares = allMiddlewares.filter((middleware) => {
+			return middleware.command === node.token && middleware.parentPath === node.directoryPath;
+		}).map((middleware) => middleware.id);
+		return [
+			...globalMiddlewares,
+			...directoryMiddlewares,
+			...commandSpecificMiddlewares
+		];
+	}
+	/**
+	* @private
+	* @internal
+	*/
+	addDiagnostic(code, message, path) {
+		this.diagnostics.push({
+			code,
+			message,
+			path: (0, node_path.normalize)(path)
+		});
 	}
 	/**
 	* @private
@@ -166,7 +572,9 @@ var CommandsRouter = class {
 				middlewares: []
 			};
 			this.commands.set(command.id, command);
-		} else if (this.isMiddleware(name)) {
+			return { command };
+		}
+		if (this.isMiddleware(name)) {
 			var _name$match;
 			const middleware = {
 				id: crypto.randomUUID(),
@@ -178,7 +586,9 @@ var CommandsRouter = class {
 				command: COMMAND_MIDDLEWARE_PATTERN.test(name) ? ((_name$match = name.match(COMMAND_MIDDLEWARE_PATTERN)) === null || _name$match === void 0 ? void 0 : _name$match[1]) || null : null
 			};
 			this.middlewares.set(middleware.id, middleware);
+			return { middleware };
 		}
+		return {};
 	}
 	/**
 	* @private
@@ -189,7 +599,9 @@ var CommandsRouter = class {
 			const commandPath = command.parentPath;
 			const allMiddlewares = Array.from(this.middlewares.values());
 			const commandSpecificMiddlewares = allMiddlewares.filter((middleware) => middleware.command === command.name).map((middleware) => middleware.id);
-			const directorySpecificMiddlewares = allMiddlewares.filter((middleware) => !middleware.global && !middleware.command && middleware.parentPath === commandPath).map((middleware) => middleware.id);
+			const directorySpecificMiddlewares = allMiddlewares.filter((middleware) => {
+				return !middleware.global && !middleware.command && middleware.parentPath === commandPath;
+			}).map((middleware) => middleware.id);
 			command.middlewares = [
 				...allMiddlewares.filter((middleware) => middleware.global).map((middleware) => middleware.id),
 				...directorySpecificMiddlewares,
@@ -204,6 +616,15 @@ var CommandsRouter = class {
 	replaceEntrypoint(path) {
 		return (0, node_path.normalize)(path).replace(this.options.entrypoint, "");
 	}
+	/**
+	* @private
+	* @internal
+	*/
+	isWithinPath(basePath, targetPath) {
+		const rel = (0, node_path.relative)((0, node_path.normalize)(basePath), (0, node_path.normalize)(targetPath));
+		if (!rel) return true;
+		return !rel.startsWith("..") && !(0, node_path.isAbsolute)(rel);
+	}
 };
 
 //#endregion

package/dist/app/router/CommandsRouter.js.map

@@ -1 +1 @@
-{"version":3,"file":"CommandsRouter.js","names":[],"sources":["../../../src/app/router/CommandsRouter.ts"],"sourcesContent":["import { Collection } from 'discord.js';\nimport { Dirent, existsSync } from 'node:fs';\nimport { readdir } from 'node:fs/promises';\nimport { basename, extname, join, normalize } from 'node:path';\n\n/**\n * Represents a command with its metadata and middleware associations.\n */\nexport interface Command {\n  id: string;\n  name: string;\n  path: string;\n  relativePath: string;\n  parentPath: string;\n  middlewares: Array<string>;\n  category: string | null;\n}\n\n/**\n * Represents a middleware with its metadata and scope.\n */\nexport interface Middleware {\n  id: string;\n  name: string;\n  path: string;\n  relativePath: string;\n  parentPath: string;\n  global: boolean;\n  command: string | null;\n}\n\n/**\n * Data structure containing parsed commands and middleware.\n */\nexport interface ParsedCommandData {\n  commands: Record<string, Command>;\n  middlewares: Record<string, Middleware>;\n}\n\n/**\n * Configuration options for the commands router.\n */\nexport interface CommandsRouterOptions {\n  entrypoint: string;\n}\n\n/**\n * @private\n * @internal\n */\nconst MIDDLEWARE_PATTERN = /^\\+middleware\\.(m|c)?(j|t)sx?$/;\n\n/**\n * @private\n * @internal\n */\nconst COMMAND_MIDDLEWARE_PATTERN =\n  /^\\+([^+().][^().]*)\\.middleware\\.(m|c)?(j|t)sx?$/;\n\n/**\n * @private\n * @internal\n */\nconst GLOBAL_MIDDLEWARE_PATTERN = /^\\+global-middleware\\.(m|c)?(j|t)sx?$/;\n\n/**\n * @private\n * @internal\n */\nconst COMMAND_PATTERN = /^([^+().][^().]*)\\.(m|c)?(j|t)sx?$/;\n\n/**\n * @private\n * @internal\n */\nconst CATEGORY_PATTERN = /^\\(.+\\)$/;\n\n/**\n * Handles discovery and parsing of command and middleware files in the filesystem.\n */\nexport class CommandsRouter {\n  /**\n   * @private\n   * @internal\n   */\n  private commands = new Collection<string, Command>();\n\n  /**\n   * @private\n   * @internal\n   */\n  private middlewares = new Collection<string, Middleware>();\n\n  /**\n   * Creates a new CommandsRouter instance.\n   * @param options - Configuration options for the router\n   */\n  public constructor(private readonly options: CommandsRouterOptions) {}\n\n  /**\n   * Populates the router with existing command and middleware data.\n   * @param data - Parsed command data to populate with\n   */\n  public populate(data: ParsedCommandData) {\n    for (const [id, command] of Object.entries(data.commands)) {\n      this.commands.set(id, command);\n    }\n\n    for (const [id, middleware] of Object.entries(data.middlewares)) {\n      this.middlewares.set(id, middleware);\n    }\n  }\n\n  /**\n   * Checks if the configured entrypoint path exists.\n   * @returns True if the path exists\n   */\n  public isValidPath(): boolean {\n    return existsSync(this.options.entrypoint);\n  }\n\n  /**\n   * @private\n   * @internal\n   */\n  private isCommand(name: string): boolean {\n    return COMMAND_PATTERN.test(name);\n  }\n\n  /**\n   * @private\n   * @internal\n   */\n  private isMiddleware(name: string): boolean {\n    return (\n      MIDDLEWARE_PATTERN.test(name) ||\n      GLOBAL_MIDDLEWARE_PATTERN.test(name) ||\n      COMMAND_MIDDLEWARE_PATTERN.test(name)\n    );\n  }\n\n  /**\n   * @private\n   * @internal\n   */\n  private isCategory(name: string): boolean {\n    return CATEGORY_PATTERN.test(name);\n  }\n\n  /**\n   * Clears all loaded commands and middleware.\n   */\n  public clear() {\n    this.commands.clear();\n    this.middlewares.clear();\n  }\n\n  /**\n   * Scans the filesystem for commands and middleware files.\n   * @returns Parsed command data\n   */\n  public async scan() {\n    const entries = await readdir(this.options.entrypoint, {\n      withFileTypes: true,\n    });\n\n    for (const entry of entries) {\n      // ignore _ prefixed files\n      if (entry.name.startsWith('_')) continue;\n\n      const fullPath = join(this.options.entrypoint, entry.name);\n\n      if (entry.isDirectory()) {\n        const category = this.isCategory(entry.name)\n          ? entry.name.slice(1, -1)\n          : null;\n\n        await this.traverse(fullPath, category);\n      } else {\n        await this.handle(entry);\n      }\n    }\n\n    await this.applyMiddlewares();\n\n    return this.toJSON();\n  }\n\n  /**\n   * Gets the raw command and middleware collections.\n   * @returns Object containing commands and middlewares collections\n   */\n  public getData() {\n    return {\n      commands: this.commands,\n      middlewares: this.middlewares,\n    };\n  }\n\n  /**\n   * Converts the loaded data to a JSON-serializable format.\n   * @returns Plain object with commands and middlewares\n   */\n  public toJSON() {\n    return {\n      commands: Object.fromEntries(this.commands.entries()),\n      middlewares: Object.fromEntries(this.middlewares.entries()),\n    };\n  }\n\n  /**\n   * @private\n   * @internal\n   */\n  private async traverse(path: string, category: string | null) {\n    const entries = await readdir(path, {\n      withFileTypes: true,\n    });\n\n    for (const entry of entries) {\n      // ignore _ prefixed files\n      if (entry.name.startsWith('_')) continue;\n\n      if (entry.isFile()) {\n        if (this.isCommand(entry.name) || this.isMiddleware(entry.name)) {\n          await this.handle(entry, category);\n        }\n      } else if (\n        entry.isDirectory() &&\n        this.isCategory(entry.name) &&\n        category\n      ) {\n        // nested category\n        const nestedCategory = this.isCategory(entry.name)\n          ? `${category}:${entry.name.slice(1, -1)}`\n          : null;\n        await this.traverse(join(path, entry.name), nestedCategory);\n      }\n\n      // TODO: handle subcommands\n    }\n  }\n\n  /**\n   * @private\n   * @internal\n   */\n  private async handle(entry: Dirent, category: string | null = null) {\n    const name = entry.name;\n    const path = join(entry.parentPath, entry.name);\n\n    if (this.isCommand(name)) {\n      const command: Command = {\n        id: crypto.randomUUID(),\n        name: basename(path, extname(path)),\n        path,\n        category,\n        parentPath: entry.parentPath,\n        relativePath: this.replaceEntrypoint(path),\n        middlewares: [],\n      };\n\n      this.commands.set(command.id, command);\n    } else if (this.isMiddleware(name)) {\n      const middleware: Middleware = {\n        id: crypto.randomUUID(),\n        name: basename(path, extname(path)),\n        path,\n        relativePath: this.replaceEntrypoint(path),\n        parentPath: entry.parentPath,\n        global: GLOBAL_MIDDLEWARE_PATTERN.test(name),\n        command: COMMAND_MIDDLEWARE_PATTERN.test(name)\n          ? name.match(COMMAND_MIDDLEWARE_PATTERN)?.[1] || null\n          : null,\n      };\n\n      this.middlewares.set(middleware.id, middleware);\n    }\n  }\n\n  /**\n   * @private\n   * @internal\n   */\n  private applyMiddlewares() {\n    this.commands.forEach((command) => {\n      const commandPath = command.parentPath;\n      const allMiddlewares = Array.from(this.middlewares.values());\n\n      const commandSpecificMiddlewares = allMiddlewares\n        .filter((middleware) => middleware.command === command.name)\n        .map((middleware) => middleware.id);\n\n      const directorySpecificMiddlewares = allMiddlewares\n        .filter(\n          (middleware) =>\n            !middleware.global &&\n            !middleware.command &&\n            middleware.parentPath === commandPath,\n        )\n        .map((middleware) => middleware.id);\n\n      const globalMiddlewares = allMiddlewares\n        .filter((middleware) => middleware.global)\n        .map((middleware) => middleware.id);\n\n      command.middlewares = [\n        ...globalMiddlewares,\n        ...directorySpecificMiddlewares,\n        ...commandSpecificMiddlewares,\n      ];\n    });\n  }\n\n  /**\n   * @private\n   * @internal\n   */\n  private replaceEntrypoint(path: string) {\n    const normalized = normalize(path);\n    return normalized.replace(this.options.entrypoint, '');\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"CommandsRouter.js","names":[],"sources":[],"mappings":""}

package/dist/app/router/EventsRouter.d.ts

@@ -1,2 +1,2 @@
-import { i as ParsedEvent, n as EventsRouterOptions, r as EventsTree, t as EventsRouter } from "../../EventsRouter-EuuSu6NH.js";
-export { EventsRouter, EventsRouterOptions, EventsTree, ParsedEvent };
+import { a as ParsedEvent, i as EventsTree, n as EventsRouterFileChangeType, r as EventsRouterOptions, t as EventsRouter } from "../../EventsRouter-Bt63ZuEF.js";
+export { EventsRouter, EventsRouterFileChangeType, EventsRouterOptions, EventsTree, ParsedEvent };