@adonisjs/assembler 8.0.0-next.3 → 8.0.0-next.30

package/build/main-BeV45LeF.js

@@ -0,0 +1,246 @@
+import { i as isRelative, m as debug_default, t as VirtualFileSystem } from "./virtual_file_system-bGeoWsK-.js";
+import { a as nodeToPlainText, i as inspectMethodArguments, n as inspectClass, o as searchValidatorDirectUsage, r as inspectClassMethods, t as findImport } from "./helpers-DDurYRsZ.js";
+import { cliui } from "@poppinss/cliui";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import string from "@poppinss/utils/string";
+import { join, relative } from "node:path";
+import StringBuilder from "@poppinss/utils/string_builder";
+import { parseImports } from "parse-imports";
+import { resolve } from "import-meta-resolve";
+var PathsResolver = class {
+	#appRoot;
+	#resolvedPaths = {};
+	#resolver = (specifier, parentPath) => resolve(specifier, parentPath);
+	constructor(appRoot) {
+		this.#appRoot = pathToFileURL(join(appRoot, "index.js")).href;
+	}
+	use(resolver) {
+		this.#resolver = resolver;
+	}
+	resolve(specifier, rewriteAliasImportExtension = false) {
+		if (isRelative(specifier)) throw new Error("Cannot resolve relative paths using PathsResolver");
+		const cacheKey = specifier;
+		const cached = this.#resolvedPaths[cacheKey];
+		if (cached) return cached;
+		let resolvedPath = fileURLToPath(this.#resolver(specifier, this.#appRoot));
+		if (rewriteAliasImportExtension && specifier.startsWith("#") && resolvedPath.endsWith(".js")) resolvedPath = resolvedPath.replace(/\.js$/, ".ts");
+		this.#resolvedPaths[cacheKey] = resolvedPath;
+		return this.#resolvedPaths[cacheKey];
+	}
+};
+async function extractValidators(appRoot, vfs, controller) {
+	const root = await vfs.get(controller.path);
+	const fileContents = root.text();
+	const controllerClass = inspectClass(root);
+	if (!controllerClass) {
+		debug_default(`No class defined within the "%s"`, controller.import.specifier);
+		return;
+	}
+	const method = inspectClassMethods(controllerClass).find((methodNode) => {
+		return methodNode.find({ rule: { kind: "property_identifier" } })?.text() === controller.method;
+	});
+	if (!method) {
+		debug_default(`Unable to find "%s" method in "%s"`, controller.method, controller.import.specifier);
+		return;
+	}
+	const validationCalls = inspectMethodArguments(method, ["request.validateUsing", "vine.validate"]).map((node) => {
+		const firstArg = node.find({ rule: { any: [{ kind: "identifier" }, { kind: "member_expression" }] } });
+		if (!firstArg) return;
+		return nodeToPlainText(firstArg);
+	}).filter((node) => node !== void 0).concat(searchValidatorDirectUsage(method).map((node) => nodeToPlainText(node)));
+	if (!validationCalls.length) {
+		debug_default(`Unable to detect any validation calls in "%s.%s" method`, controller.import.specifier, controller.method);
+		return;
+	}
+	const controllerName = controllerClass.find({ rule: { kind: "type_identifier" } }).text();
+	const controllerURL = pathToFileURL(controller.path);
+	return (await Promise.all(validationCalls.map(async (validationCall) => {
+		if (validationCall.split(".")[0] === controllerName) return {
+			name: validationCall,
+			import: {
+				specifier: controller.import.specifier,
+				type: "default",
+				value: controllerName
+			}
+		};
+		const importCall = await findImport(fileContents, validationCall);
+		if (!importCall) {
+			debug_default("Unable to find import for \"%s\" used by \"%s.%s\" method", validationCall, controller.import.specifier, controller.method);
+			return null;
+		}
+		return {
+			name: validationCall,
+			import: {
+				specifier: isRelative(importCall.specifier) ? string.toUnixSlash(relative(appRoot, fileURLToPath(new URL(importCall.specifier, controllerURL)))) : importCall.specifier,
+				type: importCall.clause.type,
+				value: importCall.clause.value
+			}
+		};
+	}))).filter((value) => !!value);
+}
+var RoutesScanner = class {
+	#filter;
+	#appRoot;
+	#controllerRoutes = {};
+	#scannedRoutes = [];
+	#computeResponseTypes;
+	#computeRequestTypes;
+	#extractValidators;
+	ui = cliui();
+	pathsResolver;
+	rules = {
+		request: {},
+		response: {}
+	};
+	constructor(appRoot, rulesCollection) {
+		this.#appRoot = appRoot;
+		this.pathsResolver = new PathsResolver(appRoot);
+		rulesCollection.forEach((rules) => {
+			Object.assign(this.rules.request, rules.request);
+			Object.assign(this.rules.response, rules.response);
+		});
+	}
+	#shouldSkipRoute(route) {
+		if (this.#filter) return !this.#filter(route);
+		return false;
+	}
+	#prepareRequestTypes(route) {
+		if (!route.validators) return;
+		return {
+			type: route.validators.reduce((result, validator) => {
+				const validatorExport = validator.import.type === "default" ? ".default" : validator.import.type === "named" ? `.${validator.import.value}` : "";
+				const [, ...segments] = validator.name.split(".");
+				const namespace = segments.map((segment) => `['${segment}']`).join("");
+				result.push(`InferInput<(typeof import('${validator.import.specifier}')${validatorExport})${namespace}>`);
+				return result;
+			}, []).join("|"),
+			imports: [`import { InferInput } from '@vinejs/vine/types'`]
+		};
+	}
+	async #inspectControllerSpecifier(importExpression, method) {
+		const importedModule = [...await parseImports(importExpression)].find(($import) => $import.isDynamicImport && $import.moduleSpecifier.value);
+		if (!importedModule || importedModule.moduleSpecifier.type !== "package" || !importedModule.moduleSpecifier.value) return null;
+		const specifier = importedModule.moduleSpecifier.value;
+		const name = new StringBuilder(specifier.split("/").pop()).removeSuffix("Controller").pascalCase().suffix("Controller").toString();
+		return {
+			name,
+			method: method ?? "handle",
+			path: string.toUnixSlash(this.pathsResolver.resolve(specifier, true)),
+			import: {
+				specifier,
+				type: "default",
+				value: name
+			}
+		};
+	}
+	async #setResponse(route, controller) {
+		route.response = await this.#computeResponseTypes?.(route, controller, this) ?? {
+			type: `ReturnType<import('${controller.import.specifier}').default['${controller.method}']>`,
+			imports: []
+		};
+		debug_default("computed route \"%s\" response %O", route.name, route.response);
+	}
+	async #setRequest(route, controller, vfs) {
+		route.validators = await this.#extractValidators?.(route, controller, this) ?? await extractValidators(this.#appRoot, vfs, controller);
+		debug_default("computed route \"%s\" validators %O", route.name, route.validators);
+		route.request = await this.#computeRequestTypes?.(route, controller, this) ?? this.#prepareRequestTypes(route);
+		debug_default("computed route \"%s\" request input %O", route.name, route.request);
+	}
+	#processRouteWithoutController(route) {
+		if (!route.name) {
+			debug_default(`skipping route "%s" as it does not have a name`, route.pattern);
+			return;
+		}
+		const scannedRoute = {
+			name: route.name,
+			domain: route.domain,
+			methods: route.methods,
+			pattern: route.pattern,
+			tokens: route.tokens,
+			request: this.rules.request[route.name],
+			response: this.rules.response[route.name]
+		};
+		debug_default("scanned route without controller %O", scannedRoute);
+		this.#scannedRoutes.push(scannedRoute);
+	}
+	async #processRouteWithController(route, vfs) {
+		if (!route.handler || !route.handler.importExpression) return this.#processRouteWithoutController(route);
+		const controller = await this.#inspectControllerSpecifier(route.handler.importExpression, route.handler.method);
+		if (!controller) return this.#processRouteWithoutController(route);
+		debug_default("processing route \"%s\" with inspected controller %O", route.name, controller);
+		route.name = route.name ?? new StringBuilder(controller.name).removeSuffix("Controller").snakeCase().suffix(`.${string.snakeCase(controller.method)}`).toString();
+		if (this.#shouldSkipRoute(route)) return;
+		const scannedRoute = {
+			name: route.name,
+			domain: route.domain,
+			methods: route.methods,
+			pattern: route.pattern,
+			tokens: route.tokens,
+			request: this.rules.request[route.name],
+			response: this.rules.response[route.name],
+			controller
+		};
+		debug_default("scanned route %O", scannedRoute);
+		this.#scannedRoutes.push(scannedRoute);
+		if (!scannedRoute.request || !scannedRoute.response) {
+			debug_default("tracking controller for rescanning %O", scannedRoute);
+			this.#controllerRoutes[controller.path] ??= [];
+			this.#controllerRoutes[controller.path].push(scannedRoute);
+			if (!scannedRoute.response) await this.#setResponse(scannedRoute, controller);
+			if (!scannedRoute.request) await this.#setRequest(scannedRoute, controller, vfs);
+		}
+	}
+	async #processRoute(route, vfs) {
+		if (route.name && this.#shouldSkipRoute(route)) {
+			debug_default("route skipped route: %O, rules: %O", route, this.rules);
+			return;
+		}
+		if (typeof route.handler === "function") {
+			this.#processRouteWithoutController(route);
+			return;
+		}
+		await this.#processRouteWithController(route, vfs);
+	}
+	defineResponse(callback) {
+		this.#computeResponseTypes = callback;
+		return this;
+	}
+	defineRequest(callback) {
+		this.#computeRequestTypes = callback;
+		return this;
+	}
+	extractValidators(callback) {
+		this.#extractValidators = callback;
+		return this;
+	}
+	getScannedRoutes() {
+		return this.#scannedRoutes;
+	}
+	getControllers() {
+		return Object.keys(this.#controllerRoutes);
+	}
+	async invalidate(controllerPath) {
+		const controllerRoutes = this.#controllerRoutes[controllerPath];
+		if (!controllerRoutes || !controllerRoutes.length) {
+			debug_default("\"%s\" controllers is not part of scanned controllers %O", controllerPath, this.#controllerRoutes);
+			return false;
+		}
+		for (let scannedRoute of controllerRoutes) if (scannedRoute.controller) {
+			debug_default("invalidating route %O", scannedRoute);
+			const vfs = new VirtualFileSystem(this.#appRoot);
+			await this.#setResponse(scannedRoute, scannedRoute.controller);
+			await this.#setRequest(scannedRoute, scannedRoute.controller, vfs);
+		}
+		return true;
+	}
+	filter(filterFn) {
+		this.#filter = filterFn;
+		return this;
+	}
+	async scan(routes) {
+		const vfs = new VirtualFileSystem(this.#appRoot);
+		for (const route of routes) await this.#processRoute(route, vfs);
+		vfs.invalidate();
+	}
+};
+export { RoutesScanner as t };

package/build/main-CknPN3rJ.js

@@ -0,0 +1,188 @@
+import { f as throttle, l as removeExtension, m as debug_default, t as VirtualFileSystem } from "./virtual_file_system-bGeoWsK-.js";
+import { mkdir, writeFile } from "node:fs/promises";
+import string from "@poppinss/utils/string";
+import { dirname, join, relative } from "node:path/posix";
+import StringBuilder from "@poppinss/utils/string_builder";
+var FileBuffer = class FileBuffer {
+	#eol = false;
+	#buffer = [];
+	#identationSize = 0;
+	#compiledOutput;
+	create() {
+		return new FileBuffer();
+	}
+	get size() {
+		return this.#buffer.length;
+	}
+	eol(enabled) {
+		this.#eol = enabled;
+		return this;
+	}
+	writeLine(text) {
+		if (typeof text === "string") this.#buffer.push(`${" ".repeat(this.#identationSize)}${text}\n`);
+		else {
+			this.#buffer.push(text);
+			this.#buffer.push("");
+		}
+		return this;
+	}
+	write(text) {
+		if (typeof text === "string") this.#buffer.push(`${" ".repeat(this.#identationSize)}${text}`);
+		else this.#buffer.push(text);
+		return this;
+	}
+	indent() {
+		this.#identationSize += 2;
+		return this;
+	}
+	dedent() {
+		this.#identationSize -= 2;
+		if (this.#identationSize < 0) this.#identationSize = 0;
+		return this;
+	}
+	toString() {
+		return this.flush();
+	}
+	flush() {
+		if (this.#compiledOutput !== void 0) return this.#compiledOutput;
+		this.#compiledOutput = this.#buffer.join("\n");
+		return this.#eol ? `${this.#compiledOutput}\n` : this.#compiledOutput;
+	}
+};
+var IndexGeneratorSource = class {
+	#appRoot;
+	#output;
+	#source;
+	#outputDirname;
+	#vfs;
+	#config;
+	#cliLogger;
+	#generateOutput = throttle(async () => {
+		const buffer = new FileBuffer().eol(true);
+		if (this.#config.as === "barrelFile") this.#asBarrelFile(this.#vfs, buffer, this.#config.exportName, this.#config.disableLazyImports);
+		else this.#config.as(this.#vfs, buffer, this.#config, { toImportPath: this.#createBarrelFileImportGenerator(this.#source, this.#outputDirname, this.#config) });
+		await mkdir(dirname(this.#output), { recursive: true });
+		await writeFile(this.#output, buffer.flush());
+	});
+	name;
+	constructor(name, appRoot, cliLogger, config) {
+		this.name = name;
+		this.#config = config;
+		this.#appRoot = appRoot;
+		this.#cliLogger = cliLogger;
+		this.#source = join(this.#appRoot, this.#config.source);
+		this.#output = join(this.#appRoot, this.#config.output);
+		this.#outputDirname = dirname(this.#output);
+		this.#vfs = new VirtualFileSystem(this.#source, {
+			glob: this.#config.glob,
+			filter: this.#config.filter
+		});
+	}
+	#treeToString(input, buffer) {
+		Object.keys(input).forEach((key) => {
+			const value = input[key];
+			if (typeof value === "string") buffer.write(`${key}: ${value},`);
+			else {
+				buffer.write(`${key}: {`).indent();
+				this.#treeToString(value, buffer);
+				buffer.dedent().write(`},`);
+			}
+		});
+	}
+	#createBarrelFileKeyGenerator(config) {
+		return function(key) {
+			let paths = key.split("/");
+			let baseName = new StringBuilder(paths.pop());
+			if (config.skipSegments?.length) paths = paths.filter((p) => !config.skipSegments.includes(p));
+			if (config.computeBaseName) baseName = config.computeBaseName(baseName);
+			else baseName = baseName.removeSuffix(config.removeSuffix ?? "").pascalCase();
+			return [...paths.map((p) => string.camelCase(p)), baseName.toString()].join("/");
+		};
+	}
+	#createBarrelFileImportGenerator(source, outputDirname, config) {
+		return function(filePath) {
+			if (config.importAlias) {
+				debug_default("converting \"%s\" to import alias, source \"%s\"", filePath, source);
+				return removeExtension(filePath.replace(source, config.importAlias));
+			}
+			debug_default("converting \"%s\" to relative import, source \"%s\"", filePath, outputDirname);
+			return relative(outputDirname, filePath);
+		};
+	}
+	#asBarrelFile(vfs, buffer, exportName, disableLazyImports) {
+		const useEagerImports = disableLazyImports === true ? true : false;
+		const keyGenerator = this.#createBarrelFileKeyGenerator(this.#config);
+		const importsBuffer = buffer.create();
+		const importGenerator = this.#createBarrelFileImportGenerator(this.#source, this.#outputDirname, this.#config);
+		const tree = vfs.asTree({
+			transformKey: keyGenerator,
+			transformValue: (filePath, key) => {
+				if (useEagerImports) {
+					const importKey = new StringBuilder(key).pascalCase().toString();
+					importsBuffer.write(`import ${importKey} from '${importGenerator(filePath)}'`);
+					return importKey;
+				}
+				return `() => import('${importGenerator(filePath)}')`;
+			}
+		});
+		if (!Object.keys(tree).length) {
+			buffer.write(`export const ${exportName} = {}`);
+			return;
+		}
+		if (useEagerImports) buffer.writeLine(importsBuffer);
+		buffer.write(`export const ${exportName} = {`).indent();
+		this.#treeToString(tree, buffer);
+		buffer.dedent().write(`}`);
+	}
+	#logCreation(startTime) {
+		this.#cliLogger.info(`created ${this.#config.output}`, { startTime });
+	}
+	async addFile(filePath) {
+		if (this.#vfs.add(filePath)) {
+			debug_default("file added, re-generating \"%s\" index", this.name);
+			const startTime = process.hrtime();
+			await this.#generateOutput();
+			this.#logCreation(startTime);
+		}
+	}
+	async removeFile(filePath) {
+		if (this.#vfs.remove(filePath)) {
+			debug_default("file removed, re-generating \"%s\" index", this.name);
+			const startTime = process.hrtime();
+			await this.#generateOutput();
+			this.#logCreation(startTime);
+		}
+	}
+	async generate() {
+		debug_default("generating \"%s\" index", this.name);
+		await this.#vfs.scan();
+		await this.#generateOutput();
+	}
+};
+var IndexGenerator = class {
+	appRoot;
+	#sources = {};
+	#cliLogger;
+	constructor(appRoot, cliLogger) {
+		this.appRoot = appRoot;
+		this.#cliLogger = cliLogger;
+	}
+	add(name, config) {
+		this.#sources[name] = new IndexGeneratorSource(name, this.appRoot, this.#cliLogger, config);
+		return this;
+	}
+	async addFile(filePath) {
+		const sources = Object.values(this.#sources);
+		for (let source of sources) await source.addFile(filePath);
+	}
+	async removeFile(filePath) {
+		const sources = Object.values(this.#sources);
+		for (let source of sources) await source.removeFile(filePath);
+	}
+	async generate() {
+		const sources = Object.values(this.#sources);
+		for (let source of sources) await source.generate();
+		if (sources.length) this.#cliLogger.info(`codegen: created ${sources.length} file(s)`);
+	}
+};
+export { FileBuffer as n, IndexGenerator as t };

package/build/src/bundler.d.ts

@@ -1,13 +1,28 @@
 import type tsStatic from 'typescript';
 import type { BundlerOptions } from './types/common.ts';
 import { type SupportedPackageManager } from './types/code_transformer.ts';
+/**
+ * List of package managers we support in order to
+ * copy lockfiles
+ */
+export declare const SUPPORTED_PACKAGE_MANAGERS: {
+    [K in SupportedPackageManager]: {
+        packageManagerFiles: string[];
+        installCommand: string;
+    };
+};
 /**
  * The bundler class exposes the API to build an AdonisJS project.
+ *
+ * @example
+ * const bundler = new Bundler(new URL('./'), ts, { hooks: [] })
+ * const success = await bundler.bundle()
  */
 export declare class Bundler {
     #private;
-    cwd: URL;
-    options: BundlerOptions;
+    /**
+     * CLI UI instance for displaying colorful messages and progress information
+     */
     ui: {
         colors: import("@poppinss/colors/types").Colors;
         logger: import("@poppinss/cliui").Logger;
@@ -30,12 +45,38 @@ export declare class Bundler {
         useColors(colorsToUse: import("@poppinss/colors/types").Colors): void;
     };
     /**
-     * Package manager detect from the project environment
+     * Package manager detected from the project environment
      */
     packageManager: SupportedPackageManager;
+    /**
+     * The current working directory URL
+     */
+    cwd: URL;
+    /**
+     * The current working project directory path as string
+     */
+    cwdPath: string;
+    /**
+     * Bundler configuration options including hooks and meta files
+     */
+    options: BundlerOptions;
+    /**
+     * Create a new bundler instance
+     *
+     * @param cwd - The current working directory URL
+     * @param ts - TypeScript module reference
+     * @param options - Bundler configuration options
+     */
     constructor(cwd: URL, ts: typeof tsStatic, options: BundlerOptions);
     /**
      * Bundles the application to be run in production
+     *
+     * @param stopOnError - Whether to stop the build process on TypeScript errors
+     * @param client - Override the detected package manager
+     * @returns Promise that resolves to true if build succeeded, false otherwise
+     *
+     * @example
+     * const success = await bundler.bundle(true, 'npm')
      */
     bundle(stopOnError?: boolean, client?: SupportedPackageManager): Promise<boolean>;
 }

package/build/src/code_scanners/routes_scanner/main.d.ts

@@ -1,11 +1,26 @@
 import { type AsyncOrSync } from '@poppinss/utils/types';
 import { PathsResolver } from '../../paths_resolver.ts';
-import { AstFileSystem } from '../../ast_file_system.ts';
-import { type ScannedRoute, type RoutesListItem, type ScannedController, type RoutesScannerRules } from '../../types/code_scanners.ts';
+import { type ScannedRoute, type RoutesListItem, type ScannedController, type RoutesScannerRules, type RoutesScannerFilterFn } from '../../types/code_scanners.ts';
+/**
+ * RoutesScanner is responsible for scanning application routes,
+ * extracting their controllers, validators, request and response types.
+ *
+ * The RoutesScanner analyzes route definitions to extract TypeScript type information
+ * for request validation, response types, and controller methods. It supports custom
+ * rules for overriding default behavior and provides hooks for extending functionality.
+ *
+ * @example
+ * const scanner = new RoutesScanner(appRoot, [rules])
+ * scanner.defineResponse((route, controller) => {
+ *   return { type: 'CustomResponseType', imports: [] }
+ * })
+ * await scanner.scan(routes)
+ * const scannedRoutes = scanner.getScannedRoutes()
+ */
 export declare class RoutesScanner {
     #private;
     /**
-     * CLI UI to log colorful messages
+     * CLI UI instance to log colorful messages and progress information
      */
     ui: {
         colors: import("@poppinss/colors/types").Colors;
@@ -33,21 +48,25 @@ export declare class RoutesScanner {
      * imports to absolute paths
      */
     pathsResolver: PathsResolver;
-    /**
-     * The AstFileSystem is used to convert files to AST-grep nodes.
-     * The AST is cached to speed up the performance.
-     */
-    astFileSystem: AstFileSystem;
     /**
      * The rules to apply when scanning routes
      */
     rules: RoutesScannerRules;
+    /**
+     * Create a new RoutesScanner instance
+     *
+     * @param appRoot - The root directory of the application
+     * @param rulesCollection - Collection of rules to apply during scanning
+     */
     constructor(appRoot: string, rulesCollection: RoutesScannerRules[]);
     /**
      * Register a callback to self compute the response types for
      * a given route. The callback will be executed for all
      * the routes and you must return undefined to fallback
      * to the default behavior of detecting types
+     *
+     * @param callback - Function to compute response types for routes
+     * @returns This RoutesScanner instance for method chaining
      */
     defineResponse(callback: (route: ScannedRoute, controller: ScannedController, scanner: RoutesScanner) => AsyncOrSync<ScannedRoute['response']>): this;
     /**
@@ -55,25 +74,58 @@ export declare class RoutesScanner {
      * a given route. The callback will be executed for all
      * the routes and you must return undefined to fallback
      * to the default behavior of detecting types
+     *
+     * @param callback - Function to compute request types for routes
+     * @returns This RoutesScanner instance for method chaining
      */
     defineRequest(callback: (route: ScannedRoute, controller: ScannedController, scanner: RoutesScanner) => AsyncOrSync<ScannedRoute['request']>): this;
     /**
-     * Register a callback to extract validators from the route
-     * controller.
+     * Register a callback to extract validators from the route controller
+     *
+     * @param callback - Function to extract validators from controllers
+     * @returns This RoutesScanner instance for method chaining
      */
     extractValidators(callback: (route: ScannedRoute, controller: ScannedController, scanner: RoutesScanner) => AsyncOrSync<ScannedRoute['validators']>): this;
     /**
      * Returns the scanned routes
+     *
+     * @returns Array of scanned routes with their metadata
      */
     getScannedRoutes(): ScannedRoute[];
+    /**
+     * Returns an array of controllers bound to the provided
+     * routes
+     *
+     * @returns Array of controller's absolute paths
+     */
+    getControllers(): string[];
     /**
      * Invalidating a controller will trigger computing the validators,
      * request types and the response types.
+     *
+     * @param controllerPath - Path to the controller file to invalidate
+     */
+    invalidate(controllerPath: string): Promise<boolean>;
+    /**
+     * Sets a filter function to selectively include routes during scanning.
+     *
+     * @param filterFn - Function that returns true for routes to include
+     * @returns This RoutesScanner instance for method chaining
+     *
+     * @example
+     * scanner.filter((route) => {
+     *   return route.pattern.startsWith('/api')
+     * })
      */
-    invalidate(controllerPath: string): Promise<void>;
+    filter(filterFn: RoutesScannerFilterFn): this;
     /**
      * Scans an array of Route list items and fetches their validators,
      * controllers, and request/response types.
+     *
+     * This is the main method that processes all routes and extracts
+     * their type information for code generation purposes.
+     *
+     * @param routes - Array of route list items to scan
      */
     scan(routes: RoutesListItem[]): Promise<void>;
 }

package/build/src/code_scanners/routes_scanner/main.js

@@ -0,0 +1,4 @@
+import "../../../virtual_file_system-bGeoWsK-.js";
+import { t as RoutesScanner } from "../../../main-BeV45LeF.js";
+import "../../../helpers-DDurYRsZ.js";
+export { RoutesScanner };

package/build/src/code_scanners/routes_scanner/validator_extractor.d.ts

@@ -1,8 +1,11 @@
-import { type AstFileSystem } from '../../ast_file_system.ts';
+import { type VirtualFileSystem } from '../../virtual_file_system.ts';
 import { type ScannedController, type ScannedRoute } from '../../types/code_scanners.ts';
 /**
- * Extracts the VineJS validator usage from within a controller
- * method. The following syntaxes are supported.
+ * Extracts the VineJS validator usage from within a controller method.
+ *
+ * This function analyzes controller method code to detect validator usage patterns
+ * and extracts the validator references along with their import information.
+ * The following syntaxes are supported:
  *
  * - `request.validateUsing(validatorReference)`
  * - `vine.validate(validatorReference)`
@@ -14,5 +17,10 @@ import { type ScannedController, type ScannedRoute } from '../../types/code_scan
  *
  * The app root is needed to create relative validator imports in case
  * a relative import was used within the controller file.
+ *
+ * @param appRoot - The root directory of the application
+ * @param vfs - Virtual file system instance for code analysis
+ * @param controller - The controller to analyze for validator usage
+ * @returns Promise resolving to array of validator information or undefined
  */
-export declare function extractValidators(appRoot: string, astFileSystem: AstFileSystem, controller: ScannedController): Promise<ScannedRoute['validators']>;
+export declare function extractValidators(appRoot: string, vfs: VirtualFileSystem, controller: ScannedController): Promise<ScannedRoute['validators']>;