@adonisjs/vite 5.1.0 → 6.0.0-next.0

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

@@ -0,0 +1,13 @@
+import { type Plugin } from 'vite';
+export interface ReloadOptions {
+    delay?: number;
+}
+/**
+ * Returns a Vite plugin that triggers a full browser reload whenever any file
+ * matching the supplied glob patterns changes. Patterns are resolved relative
+ * to the Vite project root.
+ *
+ * Replaces the previous `vite-plugin-restart` dependency. Only the reload
+ * (browser refresh) feature is implemented — server restart is not.
+ */
+export declare function reload(patterns: string | string[], options?: ReloadOptions): Plugin;

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

@@ -0,0 +1,20 @@
+import type { Plugin } from 'vite';
+import type { PluginOptions } from './types.ts';
+/**
+ * Returns a plugin that emits user-supplied files into the build output.
+ *
+ * `chunks` are passed to Vite's `emitFile({ type: 'chunk' })` after glob
+ * expansion. They are processed by the bundler and surface in the manifest
+ * with hashed filenames.
+ *
+ * `assets` are emitted as raw `type: 'asset'` files (no glob expansion —
+ * exact paths only) so the original source content is preserved verbatim.
+ * The `originalFileName` field tells Vite to use the source path as the
+ * manifest key, so templates can resolve them via
+ * `vite.assetPath('resources/images/logo.png')` without any post-build
+ * manifest rewriting.
+ *
+ * Returns an empty array (no-op) when neither chunks nor assets are
+ * configured.
+ */
+export declare function resolveAssets(input: PluginOptions['assets']): Plugin[];

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

@@ -22,5 +22,30 @@ export interface PluginOptions {
      * @default 'public/assets'
      */
     buildDirectory?: string;
+    /**
+     * Server-side entrypoints bundled into the SSR build output. Each
+     * entry is emitted as a single bundle (no hash, no shared chunks)
+     * under `<buildDirectory>/server/<name>.js` and becomes loadable
+     * through `vite.loadServerModule()` at runtime.
+     *
+     * Paths are relative to the project root.
+     */
+    serverEntrypoints?: string[];
+    /**
+     * Additional files to include in the build that are not imported by the
+     * entrypoints.
+     *
+     * - When passed as a `string[]`, every entry is treated as a chunk: glob
+     *   patterns are expanded and each matching file is emitted via Vite's
+     *   `emitFile({ type: 'chunk' })`.
+     * - When passed as `{ chunks?, assets? }`, `chunks` behaves identically
+     *   to the array form, while `assets` files are emitted as raw assets
+     *   (no glob support, exact paths only) and the manifest is rewritten so
+     *   the manifest key matches the source path.
+     */
+    assets?: string[] | {
+        chunks?: string[];
+        assets?: string[];
+    };
 }
-export type PluginFullOptions = Required<PluginOptions>;
+export type PluginFullOptions = Required<Omit<PluginOptions, 'assets'>>;

package/build/src/hooks/build_hook.js

@@ -1,11 +1,24 @@
-// src/hooks/build_hook.ts
 import { hooks } from "@adonisjs/core/app";
 import { createBuilder } from "vite";
+//#region src/hooks/build_hook.ts
+/**
+* This is an Assembler hook that should be executed when the application is
+* builded using the `node ace build` command.
+*
+* The hook is responsible for launching a Vite multi-build process.
+*/
 var build_hook_default = hooks.buildStarting(async (parent) => {
-  parent.ui.logger.info("building assets with vite");
-  const builder = await createBuilder({}, null);
-  await builder.buildApp();
+	/**
+	* Vite's CLI sets NODE_ENV to 'production' automatically when running
+	* `vite build`, but the programmatic `createBuilder` API does not.
+	* Without this, framework plugins (React, Vue, MDX, …) emit dev-only
+	* code paths in the production bundle.
+	*
+	* See https://github.com/remix-run/remix/issues/4081
+	*/
+	process.env.NODE_ENV = "production";
+	parent.ui.logger.info("building assets with vite");
+	await (await createBuilder({}, false)).buildApp();
 });
-export {
-  build_hook_default as default
-};
+//#endregion
+export { build_hook_default as default };

package/build/src/plugins/edge.js

@@ -1,69 +1,87 @@
-// src/plugins/edge.ts
 import { EdgeError } from "edge-error";
-var edgePluginVite = (vite) => {
-  const edgeVite = (edge) => {
-    edge.global("vite", vite);
-    edge.global("asset", vite.assetPath.bind(vite));
-    edge.registerTag({
-      tagName: "viteReactRefresh",
-      seekable: true,
-      block: false,
-      compile(parser, buffer, token) {
-        let attributes = "";
-        if (token.properties.jsArg.trim()) {
-          const jsArg = `a,${token.properties.jsArg}`;
-          const parsed = parser.utils.transformAst(
-            parser.utils.generateAST(jsArg, token.loc, token.filename),
-            token.filename,
-            parser
-          );
-          attributes = parser.utils.stringify(parsed.expressions[1]);
-        }
-        buffer.writeExpression(
-          `const __vite_hmr_script = state.vite.getReactHmrScript(${attributes})`,
-          token.filename,
-          token.loc.start.line
-        );
-        buffer.writeStatement("if(__vite_hmr_script) {", token.filename, token.loc.start.line);
-        buffer.outputExpression(
-          `__vite_hmr_script.toString()`,
-          token.filename,
-          token.loc.start.line,
-          false
-        );
-        buffer.writeStatement("}", token.filename, token.loc.start.line);
-      }
-    });
-    edge.registerTag({
-      tagName: "vite",
-      seekable: true,
-      block: false,
-      compile(parser, buffer, token) {
-        if (!token.properties.jsArg.trim()) {
-          throw new EdgeError("Missing entrypoint name", "E_RUNTIME_EXCEPTION", {
-            filename: token.filename,
-            line: token.loc.start.line,
-            col: token.loc.start.col
-          });
-        }
-        const parsed = parser.utils.transformAst(
-          parser.utils.generateAST(token.properties.jsArg, token.loc, token.filename),
-          token.filename,
-          parser
-        );
-        const entrypoints = parser.utils.stringify(parsed);
-        const methodCall = parsed.type === "SequenceExpression" ? `generateEntryPointsTags${entrypoints}` : `generateEntryPointsTags(${entrypoints})`;
-        buffer.outputExpression(
-          `(await state.vite.${methodCall}).join('\\n')`,
-          token.filename,
-          token.loc.start.line,
-          false
-        );
-      }
-    });
-  };
-  return edgeVite;
-};
-export {
-  edgePluginVite
+//#region src/plugins/edge.ts
+/**
+* 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' })
+*/
+const edgePluginVite = (vite) => {
+	const edgeVite = (edge) => {
+		edge.global("vite", vite);
+		edge.global("asset", vite.assetPath.bind(vite));
+		edge.registerTag({
+			tagName: "viteReactRefresh",
+			seekable: true,
+			block: false,
+			compile(parser, buffer, token) {
+				let attributes = "";
+				if (token.properties.jsArg.trim()) {
+					/**
+					* Converting a single argument to a SequenceExpression so that we
+					* work around the following edge cases.
+					*
+					* - If someone passes an object literal to the tag, ie { nonce: 'foo' }
+					*   it will be parsed as a LabeledStatement and not an object.
+					* - If we wrap the object literal inside parenthesis, ie ({nonce: 'foo'})
+					*   then we will end up messing other expressions like a variable reference
+					*   , or a member expression and so on.
+					* - So the best bet is to convert user supplied argument to a sequence expression
+					*   and hence ignore it during stringification.
+					*/
+					const jsArg = `a,${token.properties.jsArg}`;
+					const parsed = parser.utils.transformAst(parser.utils.generateAST(jsArg, token.loc, token.filename), token.filename, parser);
+					attributes = parser.utils.stringify(parsed.expressions[1]);
+				}
+				/**
+				* Get HMR script
+				*/
+				buffer.writeExpression(`const __vite_hmr_script = state.vite.getReactHmrScript(${attributes})`, token.filename, token.loc.start.line);
+				/**
+				* Check if the script exists (only in hot mode)
+				*/
+				buffer.writeStatement("if(__vite_hmr_script) {", token.filename, token.loc.start.line);
+				/**
+				* Write output
+				*/
+				buffer.outputExpression(`__vite_hmr_script.toString()`, token.filename, token.loc.start.line, false);
+				/**
+				* Close if block
+				*/
+				buffer.writeStatement("}", token.filename, token.loc.start.line);
+			}
+		});
+		edge.registerTag({
+			tagName: "vite",
+			seekable: true,
+			block: false,
+			compile(parser, buffer, token) {
+				/**
+				* Ensure an argument is defined
+				*/
+				if (!token.properties.jsArg.trim()) throw new EdgeError("Missing entrypoint name", "E_RUNTIME_EXCEPTION", {
+					filename: token.filename,
+					line: token.loc.start.line,
+					col: token.loc.start.col
+				});
+				const parsed = parser.utils.transformAst(parser.utils.generateAST(token.properties.jsArg, token.loc, token.filename), token.filename, parser);
+				const entrypoints = parser.utils.stringify(parsed);
+				const methodCall = parsed.type === "SequenceExpression" ? `generateEntryPointsTags${entrypoints}` : `generateEntryPointsTags(${entrypoints})`;
+				buffer.outputExpression(`(await state.vite.${methodCall}).join('\\n')`, token.filename, token.loc.start.line, false);
+			}
+		});
+	};
+	return edgeVite;
 };
+//#endregion
+export { edgePluginVite };

package/build/src/server_modules/bundled_module_resolver.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Resolves and imports server-side modules from the production SSR build.
+ *
+ * In production there is no Vite dev server — entrypoints declared as
+ * `serverEntrypoints` are pre-built into `<buildDirectory>/server` and
+ * recorded in `<buildDirectory>/server/.vite/manifest.json`. The
+ * resolver reads that manifest to map an entry source path to the
+ * emitted bundle file, then imports it through Node's native `import()`.
+ *
+ * Imports are cached per entry so repeated calls reuse the same module
+ * instance and side-effects only run once.
+ */
+export declare class BundledModuleResolver {
+    #private;
+    constructor(buildDirectory: string);
+    import<T>(entry: string): Promise<T>;
+}

package/build/src/server_modules/dev_module_runner.d.ts

@@ -0,0 +1,25 @@
+import type { ViteDevServer } from 'vite';
+import type { ModuleRunner } from 'vite/module-runner';
+import type { LoadServerModuleOptions } from '../types.ts';
+/**
+ * Hosts the Vite `ModuleRunner` used to evaluate server-side modules in
+ * development mode.
+ *
+ * Owns a single shared runner across all `loadServerModule` calls, and
+ * detects Vite dev server restarts (which replace `server.environments.ssr`
+ * with a fresh instance) so the stale runner is closed and recreated.
+ */
+export declare class DevModuleRunner {
+    #private;
+    constructor(createRunner: () => Promise<ModuleRunner>);
+    /**
+     * Imports a module through the runner. Recreates the runner if the
+     * dev server's SSR environment was swapped underneath us.
+     */
+    import<T>(server: ViteDevServer, entry: string, opts: LoadServerModuleOptions): Promise<T>;
+    /**
+     * Closes the runner, if any. Safe to call when no runner has been
+     * created yet.
+     */
+    close(): Promise<void>;
+}

package/build/src/server_modules/server_module_loader.d.ts

@@ -0,0 +1,25 @@
+import type { ViteDevServer } from 'vite';
+import type { ModuleRunner } from 'vite/module-runner';
+import type { LoadServerModuleOptions } from '../types.ts';
+/**
+ * Public entry point for loading server-side modules processed by Vite.
+ *
+ * Picks between two collaborators based on whether the Vite dev server
+ * is running:
+ *
+ * - In development, delegates to {@link DevModuleRunner} which evaluates
+ *   the entry through Vite's `ModuleRunner`, with HMR-driven cache
+ *   invalidation.
+ * - In production, delegates to {@link BundledModuleResolver} which
+ *   imports the pre-built bundle from disk.
+ *
+ * Entry strings are passed through verbatim to mirror how client
+ * `entrypoints` are handled — the caller is responsible for using the
+ * exact string declared in `serverEntrypoints`.
+ */
+export declare class ServerModuleLoader {
+    #private;
+    constructor(getDevServer: () => ViteDevServer | undefined, buildDirectory: string, createRunner: () => Promise<ModuleRunner>);
+    load<T>(entry: string, opts?: LoadServerModuleOptions): Promise<T>;
+    close(): Promise<void>;
+}

package/build/src/types.d.ts

@@ -54,3 +54,35 @@ export interface ViteOptions {
      */
     scriptAttributes?: SetAttributes;
 }
+/**
+ * Augmentable map for typing entries passed to `vite.loadServerModule`.
+ * Apps and packages merge into this interface to associate entrypoint
+ * paths with the shape of their default exports.
+ *
+ * @example
+ * declare module '@adonisjs/vite/types' {
+ *   interface ServerModuleMap {
+ *     'inertia/app/ssr.ts': typeof import('../inertia/app/ssr.ts')
+ *   }
+ * }
+ */
+export interface ServerModuleMap {
+}
+/**
+ * Options accepted by `vite.loadServerModule`.
+ */
+export interface LoadServerModuleOptions {
+    /**
+     * Clear the module runner cache before importing in dev mode.
+     *
+     * Defaults to `false` — Vite's HMR pushes invalidations into the
+     * runner, so cached modules are already kept fresh on file change.
+     * Set to `true` only when the entrypoint registers top-level state
+     * that must be reset on every load.
+     *
+     * Has no effect in production (bundled imports are always cached).
+     *
+     * @default false
+     */
+    fresh?: boolean;
+}

package/build/src/types.js

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

package/build/src/vite.d.ts

@@ -1,6 +1,6 @@
 import { type ModuleRunner } from 'vite/module-runner';
 import type { Manifest, InlineConfig, ViteDevServer, ServerModuleRunnerOptions } from 'vite';
-import type { AdonisViteElement, ViteOptions } from './types.ts';
+import type { AdonisViteElement, LoadServerModuleOptions, ServerModuleMap, ViteOptions } from './types.ts';
 /**
  * Vite class exposes the APIs to generate tags and URLs for
  * assets processed using vite.
@@ -111,6 +111,27 @@ export declare class Vite {
      * const mod = await runner.import('./app.js')
      */
     createModuleRunner(options?: ServerModuleRunnerOptions): Promise<ModuleRunner>;
+    /**
+     * Loads a server-side module that has been processed by Vite.
+     *
+     * In development, the entry is evaluated through Vite's `ModuleRunner`,
+     * giving full TypeScript / JSX / plugin support and HMR-driven cache
+     * invalidation. In production, the entry is imported from the
+     * pre-built SSR bundle on disk.
+     *
+     * The entry path must be declared in `serverEntrypoints` for the
+     * production import to succeed — otherwise the bundle won't exist.
+     *
+     * @example
+     * const mod = await vite.loadServerModule('inertia/app/ssr.ts')
+     * const html = await mod.default(payload)
+     *
+     * @example
+     * // Force re-evaluation (clear runner cache before import)
+     * await vite.loadServerModule('emails/welcome.ts', { fresh: true })
+     */
+    loadServerModule<K extends keyof ServerModuleMap>(entry: K, opts?: LoadServerModuleOptions): Promise<ServerModuleMap[K]>;
+    loadServerModule<T = unknown>(entry: string, opts?: LoadServerModuleOptions): Promise<T>;
     /**
      * Gracefully stops the Vite development server
      *

package/build/src/vite_middleware.js

@@ -1,6 +1,2 @@
-import {
-  ViteMiddleware
-} from "../chunk-AF6PV64J.js";
-export {
-  ViteMiddleware as default
-};
+import { t as ViteMiddleware } from "../vite_middleware-CuOBHhnt.js";
+export { ViteMiddleware as default };

package/build/utils-CdZpa_tV.js

@@ -0,0 +1,50 @@
+//#region src/utils.ts
+/**
+* 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' }]
+*/
+function uniqBy(array, key) {
+	const seen = /* @__PURE__ */ new Set();
+	return array.filter((item) => {
+		const k = item[key];
+		return seen.has(k) ? false : seen.add(k);
+	});
+}
+/**
+* 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'
+*/
+function makeAttributes(attributes) {
+	return Object.keys(attributes).map((key) => {
+		const value = attributes[key];
+		if (value === true) return key;
+		if (!value) return null;
+		return `${key}="${value}"`;
+	}).filter((attr) => attr !== null).join(" ");
+}
+/**
+* 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/'
+*/
+const addTrailingSlash = (url) => {
+	return url.endsWith("/") ? url : `${url}/`;
+};
+//#endregion
+export { makeAttributes as n, uniqBy as r, addTrailingSlash as t };