@adonisjs/vite 5.1.0-next.4 → 5.1.1

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/types.js

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

package/build/src/vite_middleware.d.ts

@@ -12,7 +12,6 @@ import type { Vite } from './vite.ts';
  * AdonisJS server.
  */
 export default class ViteMiddleware {
-    #private;
     protected vite: Vite;
     /**
      * Creates a new ViteMiddleware instance

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-Bszg_DDr.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 };