@adonisjs/vite 5.0.1-next.2 → 5.0.1-next.3

package/build/{chunk-AHFYQLFC.js → chunk-MM7OHCLX.js}

@@ -17,7 +17,22 @@ var Vite = class {
   #options;
   #devServer;
   #createServerPromise;
+  /**
+   * Indicates whether the Vite manifest file exists on disk
+   */
   hasManifestFile;
+  /**
+   * Creates a new Vite instance for managing asset compilation and serving
+   *
+   * @param options - Configuration options for Vite integration
+   *
+   * @example
+   * const vite = new Vite({
+   *   buildDirectory: 'build',
+   *   assetsUrl: '/assets',
+   *   manifestFile: 'build/manifest.json'
+   * })
+   */
   constructor(options) {
     this.#options = options;
     this.#options.assetsUrl = (this.#options.assetsUrl || "/").replace(/\/$/, "");
@@ -242,7 +257,24 @@ var Vite = class {
     return preloadsElements.concat(tags.map(({ tag }) => tag));
   }
   /**
-   * Generate tags for the entry points
+   * Generate HTML tags (script and link) for the specified entry points
+   *
+   * In development mode, includes HMR script and dynamically discovers CSS files.
+   * In production mode, uses the manifest file to generate optimized tags with preloading.
+   *
+   * @param entryPoints - Single entry point or array of entry points to generate tags for
+   * @param attributes - Additional HTML attributes to apply to the generated tags
+   *
+   * @example
+   * // Generate tags for a single entry point
+   * const tags = await vite.generateEntryPointsTags('app.js')
+   *
+   * @example
+   * // Generate tags for multiple entry points with custom attributes
+   * const tags = await vite.generateEntryPointsTags(
+   *   ['app.js', 'admin.js'],
+   *   { defer: true }
+   * )
    */
   async generateEntryPointsTags(entryPoints, attributes) {
     entryPoints = Array.isArray(entryPoints) ? entryPoints : [entryPoints];
@@ -252,13 +284,27 @@ var Vite = class {
     return this.#generateEntryPointsTagsWithManifest(entryPoints, attributes);
   }
   /**
-   * Returns the explicitly configured assetsUrl
+   * Returns the base URL for serving static assets
+   *
+   * @example
+   * const url = vite.assetsUrl()
+   * // Returns: '/assets' or '/build' depending on configuration
    */
   assetsUrl() {
     return this.#options.assetsUrl;
   }
   /**
-   * Returns path to a given asset file using the manifest file
+   * Returns the full URL path to a specific asset file
+   *
+   * In development mode, returns the asset path with leading slash.
+   * In production mode, uses the manifest file to return the versioned/hashed asset URL.
+   *
+   * @param asset - The relative path to the asset file
+   *
+   * @example
+   * const path = vite.assetPath('images/logo.png')
+   * // Dev: '/images/logo.png'
+   * // Prod: '/assets/images/logo-abc123.png'
    */
   assetPath(asset) {
     if (!this.hasManifestFile) {
@@ -268,9 +314,16 @@ var Vite = class {
     return this.#generateAssetUrl(chunk.file);
   }
   /**
-   * Returns the manifest file contents
+   * Returns the parsed Vite manifest file contents
    *
-   * @throws Will throw an exception when running in dev
+   * The manifest file contains information about compiled assets including
+   * file paths, integrity hashes, and import dependencies.
+   *
+   * @throws Will throw an exception when running in development mode
+   *
+   * @example
+   * const manifest = vite.manifest()
+   * console.log(manifest['app.js'].file) // 'assets/app-abc123.js'
    */
   manifest() {
     if (!this.hasManifestFile) {
@@ -282,10 +335,18 @@ var Vite = class {
     return this.#manifestCache;
   }
   /**
-   * Create the Vite Dev Server and runtime
+   * Creates and initializes the Vite development server
+   *
+   * Lazy loads Vite APIs to avoid importing them in production.
+   * The server runs in middleware mode and is configured for custom app integration.
+   *
+   * @param options - Additional Vite configuration options to merge with defaults
    *
-   * We lazy load the APIs to avoid loading it in production
-   * since we don't need it
+   * @example
+   * await vite.createDevServer({
+   *   root: './src',
+   *   server: { port: 3000 }
+   * })
    */
   async createDevServer(options) {
     const { createServer } = await import("vite");
@@ -297,30 +358,63 @@ var Vite = class {
     this.#devServer = await this.#createServerPromise;
   }
   /**
-   * Create a serverModuleRunner instance
-   * Will not be available when running in production since
-   * it needs the Vite Dev server
+   * Creates a server-side module runner for executing modules in Node.js context
+   *
+   * Only available in development mode as it requires the Vite dev server.
+   * Useful for server-side rendering and module transformation.
+   *
+   * @param options - Configuration options for the module runner
+   *
+   * @example
+   * const runner = await vite.createModuleRunner({
+   *   hmr: { port: 24678 }
+   * })
+   * const mod = await runner.import('./app.js')
    */
   async createModuleRunner(options = {}) {
     const { createServerModuleRunner } = await import("vite");
     return createServerModuleRunner(this.#devServer.environments.ssr, options);
   }
   /**
-   * Stop the Vite Dev server
+   * Gracefully stops the Vite development server
+   *
+   * Waits for the server creation promise to complete before closing.
+   *
+   * @example
+   * await vite.stopDevServer()
    */
   async stopDevServer() {
     await this.#createServerPromise;
     await this.#devServer?.close();
   }
   /**
-   * Get the Vite Dev server instance
-   * Will not be available when running in production
+   * Returns the Vite development server instance
+   *
+   * Only available in development mode after calling createDevServer().
+   * Returns undefined in production or if the server hasn't been created yet.
+   *
+   * @example
+   * const server = vite.getDevServer()
+   * if (server) {
+   *   console.log('Dev server is running on', server.config.server.port)
+   * }
    */
   getDevServer() {
     return this.#devServer;
   }
   /**
-   * Returns the script needed for the HMR working with React
+   * Generates the React Hot Module Replacement (HMR) script for development
+   *
+   * Only returns a script element in development mode. In production mode,
+   * returns null since HMR is not needed.
+   *
+   * @param attributes - Additional HTML attributes to apply to the script tag
+   *
+   * @example
+   * const hmrScript = vite.getReactHmrScript({ async: true })
+   * if (hmrScript) {
+   *   console.log(hmrScript.toString()) // <script type="module" async>...</script>
+   * }
    */
   getReactHmrScript(attributes) {
     if (this.hasManifestFile) {

package/build/{chunk-FDN2SRQF.js → chunk-TMXIREUT.js}

@@ -1,10 +1,28 @@
 // src/vite_middleware.ts
 var ViteMiddleware = class {
+  /**
+   * Creates a new ViteMiddleware instance
+   *
+   * @param vite - The Vite instance containing the dev server
+   *
+   * @example
+   * const middleware = new ViteMiddleware(viteInstance)
+   */
   constructor(vite) {
     this.vite = vite;
     this.#devServer = this.vite.getDevServer();
   }
   #devServer;
+  /**
+   * Handles HTTP requests by proxying them to the Vite dev server when appropriate
+   *
+   * @param request - The HTTP request object from AdonisJS context
+   * @param response - The HTTP response object from AdonisJS context
+   * @param next - Function to call the next middleware in the chain
+   *
+   * @example
+   * await middleware.handle(ctx, next)
+   */
   async handle({ request, response }, next) {
     if (!this.#devServer) {
       return next();

package/build/index.js

@@ -1,6 +1,6 @@
 import {
   Vite
-} from "./chunk-AHFYQLFC.js";
+} from "./chunk-MM7OHCLX.js";
 import "./chunk-ZCQTQOMI.js";
 
 // stubs/main.ts

package/build/providers/vite_provider.d.ts

@@ -5,29 +5,89 @@ declare module '@adonisjs/core/types' {
         vite: Vite;
     }
 }
+/**
+ * AdonisJS service provider for integrating Vite build tool and development server
+ *
+ * Handles lifecycle management of Vite integration including:
+ * - Registering Vite service in the container
+ * - Setting up Edge.js plugin for template integration
+ * - Managing development server startup/shutdown
+ * - Configuring CSP keywords for @adonisjs/shield
+ */
 export default class ViteProvider {
     #private;
     protected app: ApplicationService;
+    /**
+     * Creates a new ViteProvider instance
+     *
+     * @param app - The AdonisJS application service instance
+     *
+     * @example
+     * const provider = new ViteProvider(app)
+     */
     constructor(app: ApplicationService);
     /**
-     * Registers edge plugin when edge is installed
+     * Registers the Vite Edge.js plugin if Edge.js is available in the application
+     *
+     * Adds global helpers and custom tags (@vite, @viteReactRefresh) to Edge templates.
+     * Only registers the plugin if the application is using Edge.js.
+     *
+     * @example
+     * await provider.registerEdgePlugin()
+     * // Enables @vite('app.js') in Edge templates
      */
     protected registerEdgePlugin(): Promise<void>;
     /**
-     * Registers CSP keywords when @adonisjs/shield is installed
+     * Registers Content Security Policy keywords when @adonisjs/shield is installed
+     *
+     * Adds the '@viteUrl' keyword for CSP directives that returns the Vite assets URL
+     * when it's an HTTP/HTTPS URL, or an empty string otherwise.
+     *
+     * @example
+     * await provider.registerShieldKeywords()
+     * // Enables @viteUrl in CSP directives
      */
     protected registerShieldKeywords(): Promise<void>;
     /**
-     * Register Vite bindings
+     * Registers Vite service and middleware bindings in the IoC container
+     *
+     * Creates a Vite instance using configuration and determines whether
+     * the development server should run based on environment and manifest file presence.
+     *
+     * @example
+     * provider.register()
+     * // Vite service is now available via container.make('vite')
      */
     register(): void;
     /**
-     * - Register edge tags
-     * - Start Vite server when running in development or test
+     * Boots the Vite provider by registering plugins and integrations
+     *
+     * Registers Edge.js plugin and Shield CSP keywords if the respective
+     * packages are available in the application.
+     *
+     * @example
+     * await provider.boot()
      */
     boot(): Promise<void>;
     /**
-     * Stop Vite server when running in development or test
+     * Starts the Vite development server when the application is ready
+     *
+     * Only starts the server if running in development/test mode and
+     * no manifest file exists (indicating development mode).
+     *
+     * @example
+     * await provider.ready()
+     * // Dev server starts on configured port
+     */
+    ready(): Promise<void>;
+    /**
+     * Gracefully stops the Vite development server during application shutdown
+     *
+     * Only attempts to stop the server if it was started during the ready phase.
+     * Ensures clean shutdown of the development server and its resources.
+     *
+     * @example
+     * await provider.shutdown()
      */
     shutdown(): Promise<void>;
 }

package/build/providers/vite_provider.js

@@ -1,19 +1,38 @@
 import {
   Vite
-} from "../chunk-AHFYQLFC.js";
+} from "../chunk-MM7OHCLX.js";
 import {
   ViteMiddleware
-} from "../chunk-FDN2SRQF.js";
+} from "../chunk-TMXIREUT.js";
 import "../chunk-ZCQTQOMI.js";
 
 // providers/vite_provider.ts
 var ViteProvider = class {
+  /**
+   * Creates a new ViteProvider instance
+   *
+   * @param app - The AdonisJS application service instance
+   *
+   * @example
+   * const provider = new ViteProvider(app)
+   */
   constructor(app) {
     this.app = app;
   }
+  /**
+   * Flag indicating whether the Vite development server should be started
+   * Set to true when manifest file doesn't exist and running in web/test environment
+   */
   #shouldRunViteDevServer = false;
   /**
-   * Registers edge plugin when edge is installed
+   * Registers the Vite Edge.js plugin if Edge.js is available in the application
+   *
+   * Adds global helpers and custom tags (@vite, @viteReactRefresh) to Edge templates.
+   * Only registers the plugin if the application is using Edge.js.
+   *
+   * @example
+   * await provider.registerEdgePlugin()
+   * // Enables @vite('app.js') in Edge templates
    */
   async registerEdgePlugin() {
     if (this.app.usingEdgeJS) {
@@ -24,7 +43,14 @@ var ViteProvider = class {
     }
   }
   /**
-   * Registers CSP keywords when @adonisjs/shield is installed
+   * Registers Content Security Policy keywords when @adonisjs/shield is installed
+   *
+   * Adds the '@viteUrl' keyword for CSP directives that returns the Vite assets URL
+   * when it's an HTTP/HTTPS URL, or an empty string otherwise.
+   *
+   * @example
+   * await provider.registerShieldKeywords()
+   * // Enables @viteUrl in CSP directives
    */
   async registerShieldKeywords() {
     let cspKeywords = null;
@@ -46,7 +72,14 @@ var ViteProvider = class {
     });
   }
   /**
-   * Register Vite bindings
+   * Registers Vite service and middleware bindings in the IoC container
+   *
+   * Creates a Vite instance using configuration and determines whether
+   * the development server should run based on environment and manifest file presence.
+   *
+   * @example
+   * provider.register()
+   * // Vite service is now available via container.make('vite')
    */
   register() {
     const appEnvironment = this.app.getEnvironment();
@@ -57,12 +90,29 @@ var ViteProvider = class {
     this.app.container.singleton(ViteMiddleware, () => new ViteMiddleware(vite));
   }
   /**
-   * - Register edge tags
-   * - Start Vite server when running in development or test
+   * Boots the Vite provider by registering plugins and integrations
+   *
+   * Registers Edge.js plugin and Shield CSP keywords if the respective
+   * packages are available in the application.
+   *
+   * @example
+   * await provider.boot()
    */
   async boot() {
     await this.registerEdgePlugin();
     await this.registerShieldKeywords();
+  }
+  /**
+   * Starts the Vite development server when the application is ready
+   *
+   * Only starts the server if running in development/test mode and
+   * no manifest file exists (indicating development mode).
+   *
+   * @example
+   * await provider.ready()
+   * // Dev server starts on configured port
+   */
+  async ready() {
     if (!this.#shouldRunViteDevServer) {
       return;
     }
@@ -70,7 +120,13 @@ var ViteProvider = class {
     await vite.createDevServer();
   }
   /**
-   * Stop Vite server when running in development or test
+   * Gracefully stops the Vite development server during application shutdown
+   *
+   * Only attempts to stop the server if it was started during the ready phase.
+   * Ensures clean shutdown of the development server and its resources.
+   *
+   * @example
+   * await provider.shutdown()
    */
   async shutdown() {
     if (!this.#shouldRunViteDevServer) {

package/build/src/client/config.d.ts

@@ -1,11 +1,26 @@
 import type { ConfigEnv, Plugin, UserConfig } from 'vite';
 import type { PluginFullOptions } from './types.ts';
 /**
- * Resolve the `config.base` value
+ * Resolves the base URL for Vite configuration based on command and options
+ *
+ * @param config - User-provided Vite configuration
+ * @param options - Plugin options containing assetsUrl
+ * @param command - Vite command being executed ('build' or 'serve')
+ *
+ * @example
+ * const base = resolveBase(userConfig, { assetsUrl: '/assets' }, 'build')
+ * // Returns: '/assets/' for build, '/' for serve
  */
 export declare function resolveBase(config: UserConfig, options: PluginFullOptions, command: 'build' | 'serve'): string;
 /**
- * Vite config hook
+ * Merges user Vite configuration with AdonisJS-specific defaults and requirements
+ *
+ * @param options - Plugin options containing build directory and entry points
+ * @param userConfig - User-provided Vite configuration
+ * @param command - Vite environment command
+ *
+ * @example
+ * const mergedConfig = configHook(pluginOptions, userViteConfig, { command: 'build' })
  */
 export declare function configHook(options: PluginFullOptions, userConfig: UserConfig, { command }: ConfigEnv): UserConfig;
 /**

package/build/src/define_config.d.ts

@@ -1,5 +1,13 @@
 import type { ViteOptions } from './types.ts';
 /**
- * Define the backend config for Vite
+ * Creates a complete Vite configuration by merging provided options with sensible defaults
+ *
+ * @param config - Partial Vite configuration options to override defaults
+ *
+ * @example
+ * const viteConfig = defineConfig({
+ *   assetsUrl: '/static',
+ *   buildDirectory: 'dist'
+ * })
  */
 export declare function defineConfig(config: Partial<ViteOptions>): ViteOptions;

package/build/src/plugins/edge.d.ts

@@ -1,7 +1,19 @@
 import type { PluginFn } from 'edge.js/types';
 import type { Vite } from '../vite.ts';
 /**
- * The edge plugin for vite to share vite service with edge
- * and register custom tags
+ * Creates an Edge.js plugin that integrates Vite functionality into templates
+ *
+ * Registers global helpers and custom tags (@vite, @viteReactRefresh) for use in Edge templates.
+ * Provides access to asset paths and HMR functionality within template rendering.
+ *
+ * @param vite - The Vite instance to integrate with Edge templates
+ *
+ * @example
+ * const plugin = edgePluginVite(viteInstance)
+ * edge.use(plugin)
+ *
+ * // In templates:
+ * // @vite('app.js')
+ * // @viteReactRefresh({ nonce: 'abc123' })
  */
 export declare const edgePluginVite: (vite: Vite) => PluginFn<undefined>;

package/build/src/utils.d.ts

@@ -1,12 +1,32 @@
 /**
- * Returns a new array with unique items by the given key
+ * Returns a new array with unique items filtered by the specified key
+ *
+ * @param array - The array to filter for unique items
+ * @param key - The key to use for uniqueness comparison
+ *
+ * @example
+ * const users = [{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }, { id: 1, name: 'John' }]
+ * const unique = uniqBy(users, 'id')
+ * // Returns: [{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }]
  */
 export declare function uniqBy<T>(array: T[], key: keyof T): T[];
 /**
- * Convert Record of attributes to a valid HTML string
+ * Converts an object of HTML attributes to a valid HTML attribute string
+ *
+ * @param attributes - Object containing HTML attributes where values can be strings or booleans
+ *
+ * @example
+ * const attrs = makeAttributes({ class: 'btn', disabled: true, hidden: false })
+ * // Returns: 'class="btn" disabled'
  */
 export declare function makeAttributes(attributes: Record<string, string | boolean>): string;
 /**
- * Add a trailing slash if missing
+ * Adds a trailing slash to a URL if it doesn't already have one
+ *
+ * @param url - The URL string to process
+ *
+ * @example
+ * addTrailingSlash('/api') // Returns: '/api/'
+ * addTrailingSlash('/api/') // Returns: '/api/'
  */
 export declare const addTrailingSlash: (url: string) => string;

package/build/src/vite.d.ts

@@ -7,50 +7,144 @@ import type { AdonisViteElement, ViteOptions } from './types.ts';
  */
 export declare class Vite {
     #private;
+    /**
+     * Indicates whether the Vite manifest file exists on disk
+     */
     hasManifestFile: boolean;
+    /**
+     * Creates a new Vite instance for managing asset compilation and serving
+     *
+     * @param options - Configuration options for Vite integration
+     *
+     * @example
+     * const vite = new Vite({
+     *   buildDirectory: 'build',
+     *   assetsUrl: '/assets',
+     *   manifestFile: 'build/manifest.json'
+     * })
+     */
     constructor(options: ViteOptions);
     /**
-     * Generate tags for the entry points
+     * Generate HTML tags (script and link) for the specified entry points
+     *
+     * In development mode, includes HMR script and dynamically discovers CSS files.
+     * In production mode, uses the manifest file to generate optimized tags with preloading.
+     *
+     * @param entryPoints - Single entry point or array of entry points to generate tags for
+     * @param attributes - Additional HTML attributes to apply to the generated tags
+     *
+     * @example
+     * // Generate tags for a single entry point
+     * const tags = await vite.generateEntryPointsTags('app.js')
+     *
+     * @example
+     * // Generate tags for multiple entry points with custom attributes
+     * const tags = await vite.generateEntryPointsTags(
+     *   ['app.js', 'admin.js'],
+     *   { defer: true }
+     * )
      */
     generateEntryPointsTags(entryPoints: string[] | string, attributes?: Record<string, any>): Promise<AdonisViteElement[]>;
     /**
-     * Returns the explicitly configured assetsUrl
+     * Returns the base URL for serving static assets
+     *
+     * @example
+     * const url = vite.assetsUrl()
+     * // Returns: '/assets' or '/build' depending on configuration
      */
     assetsUrl(): string | undefined;
     /**
-     * Returns path to a given asset file using the manifest file
+     * Returns the full URL path to a specific asset file
+     *
+     * In development mode, returns the asset path with leading slash.
+     * In production mode, uses the manifest file to return the versioned/hashed asset URL.
+     *
+     * @param asset - The relative path to the asset file
+     *
+     * @example
+     * const path = vite.assetPath('images/logo.png')
+     * // Dev: '/images/logo.png'
+     * // Prod: '/assets/images/logo-abc123.png'
      */
     assetPath(asset: string): string;
     /**
-     * Returns the manifest file contents
+     * Returns the parsed Vite manifest file contents
      *
-     * @throws Will throw an exception when running in dev
+     * The manifest file contains information about compiled assets including
+     * file paths, integrity hashes, and import dependencies.
+     *
+     * @throws Will throw an exception when running in development mode
+     *
+     * @example
+     * const manifest = vite.manifest()
+     * console.log(manifest['app.js'].file) // 'assets/app-abc123.js'
      */
     manifest(): Manifest;
     /**
-     * Create the Vite Dev Server and runtime
+     * Creates and initializes the Vite development server
+     *
+     * Lazy loads Vite APIs to avoid importing them in production.
+     * The server runs in middleware mode and is configured for custom app integration.
+     *
+     * @param options - Additional Vite configuration options to merge with defaults
      *
-     * We lazy load the APIs to avoid loading it in production
-     * since we don't need it
+     * @example
+     * await vite.createDevServer({
+     *   root: './src',
+     *   server: { port: 3000 }
+     * })
      */
     createDevServer(options?: InlineConfig): Promise<void>;
     /**
-     * Create a serverModuleRunner instance
-     * Will not be available when running in production since
-     * it needs the Vite Dev server
+     * Creates a server-side module runner for executing modules in Node.js context
+     *
+     * Only available in development mode as it requires the Vite dev server.
+     * Useful for server-side rendering and module transformation.
+     *
+     * @param options - Configuration options for the module runner
+     *
+     * @example
+     * const runner = await vite.createModuleRunner({
+     *   hmr: { port: 24678 }
+     * })
+     * const mod = await runner.import('./app.js')
      */
     createModuleRunner(options?: ServerModuleRunnerOptions): Promise<ModuleRunner>;
     /**
-     * Stop the Vite Dev server
+     * Gracefully stops the Vite development server
+     *
+     * Waits for the server creation promise to complete before closing.
+     *
+     * @example
+     * await vite.stopDevServer()
      */
     stopDevServer(): Promise<void>;
     /**
-     * Get the Vite Dev server instance
-     * Will not be available when running in production
+     * Returns the Vite development server instance
+     *
+     * Only available in development mode after calling createDevServer().
+     * Returns undefined in production or if the server hasn't been created yet.
+     *
+     * @example
+     * const server = vite.getDevServer()
+     * if (server) {
+     *   console.log('Dev server is running on', server.config.server.port)
+     * }
      */
     getDevServer(): ViteDevServer | undefined;
     /**
-     * Returns the script needed for the HMR working with React
+     * Generates the React Hot Module Replacement (HMR) script for development
+     *
+     * Only returns a script element in development mode. In production mode,
+     * returns null since HMR is not needed.
+     *
+     * @param attributes - Additional HTML attributes to apply to the script tag
+     *
+     * @example
+     * const hmrScript = vite.getReactHmrScript({ async: true })
+     * if (hmrScript) {
+     *   console.log(hmrScript.toString()) // <script type="module" async>...</script>
+     * }
      */
     getReactHmrScript(attributes?: Record<string, any>): AdonisViteElement | null;
 }

package/build/src/vite_middleware.d.ts

@@ -2,6 +2,8 @@ import type { HttpContext } from '@adonisjs/core/http';
 import type { NextFn } from '@adonisjs/core/types/http';
 import type { Vite } from './vite.ts';
 /**
+ * Middleware for proxying requests between AdonisJS and Vite development server
+ *
  * Since Vite dev server is integrated within the AdonisJS process, this
  * middleware is used to proxy the requests to it.
  *
@@ -12,6 +14,24 @@ import type { Vite } from './vite.ts';
 export default class ViteMiddleware {
     #private;
     protected vite: Vite;
+    /**
+     * Creates a new ViteMiddleware instance
+     *
+     * @param vite - The Vite instance containing the dev server
+     *
+     * @example
+     * const middleware = new ViteMiddleware(viteInstance)
+     */
     constructor(vite: Vite);
+    /**
+     * Handles HTTP requests by proxying them to the Vite dev server when appropriate
+     *
+     * @param request - The HTTP request object from AdonisJS context
+     * @param response - The HTTP response object from AdonisJS context
+     * @param next - Function to call the next middleware in the chain
+     *
+     * @example
+     * await middleware.handle(ctx, next)
+     */
     handle({ request, response }: HttpContext, next: NextFn): Promise<any>;
 }

package/build/src/vite_middleware.js

@@ -1,6 +1,6 @@
 import {
   ViteMiddleware
-} from "../chunk-FDN2SRQF.js";
+} from "../chunk-TMXIREUT.js";
 export {
   ViteMiddleware as default
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adonisjs/vite",
   "description": "Vite plugin for AdonisJS",
-  "version": "5.0.1-next.2",
+  "version": "5.0.1-next.3",
   "engines": {
     "node": ">=24.0.0"
   },
@@ -57,19 +57,19 @@
     "@japa/snapshot": "^2.0.9",
     "@poppinss/ts-exec": "^1.4.1",
     "@release-it/conventional-changelog": "^10.0.1",
-    "@types/node": "^24.6.2",
+    "@types/node": "^24.7.2",
     "@types/supertest": "^6.0.3",
     "c8": "^10.1.3",
     "copyfiles": "^2.4.1",
     "cross-env": "^10.1.0",
     "del-cli": "^7.0.0",
     "edge.js": "^6.3.0",
-    "eslint": "^9.36.0",
+    "eslint": "^9.37.0",
     "prettier": "^3.6.2",
     "release-it": "^19.0.5",
     "supertest": "^7.1.4",
     "tsup": "^8.5.0",
-    "typedoc": "^0.28.13",
+    "typedoc": "^0.28.14",
     "typescript": "~5.9.3",
     "vite": "^7.1.9"
   },