@pajecawav/yamf 0.0.7 → 0.0.9

package/src/vite/islands.ts

@@ -5,12 +5,36 @@ import { Visitor } from "vite";
 
 const ISLAND_REGEX = /\.island\.(j|t)sx?$/;
 
+// inits that can plausibly evaluate to a component; anything else (object,
+// array, literal, class…) is left as a plain export with a warning
+const WRAPPABLE_INIT_TYPES = new Set([
+	"ArrowFunctionExpression",
+	"FunctionExpression",
+	"CallExpression",
+	"OptionalCallExpression",
+	"Identifier",
+	"ConditionalExpression",
+	"SequenceExpression",
+	"TSAsExpression",
+	"NonNullExpression",
+]);
+
+const isWrappableInit = (init: { type: string }): boolean => {
+	return WRAPPABLE_INIT_TYPES.has(init.type);
+};
+
 type Lang = NonNullable<ParserOptions["lang"]>;
 
 function langFromId(id: string): Lang {
-	if (id.endsWith(".tsx")) return "tsx";
-	if (id.endsWith(".ts")) return "ts";
-	if (id.endsWith(".jsx")) return "jsx";
+	if (id.endsWith(".tsx")) {
+		return "tsx";
+	}
+	if (id.endsWith(".ts")) {
+		return "ts";
+	}
+	if (id.endsWith(".jsx")) {
+		return "jsx";
+	}
 	return "js";
 }
 
@@ -36,6 +60,7 @@ export const islands = (): Plugin[] => {
 					s.prepend(`import __assets from "${id}?assets=client";\n`);
 
 					const seenExports = new Set<string>();
+					const warnings: string[] = [];
 
 					new Visitor({
 						ExportDefaultDeclaration(node) {
@@ -45,6 +70,9 @@ export const islands = (): Plugin[] => {
 								declaration.type !== "FunctionExpression" &&
 								declaration.type !== "ArrowFunctionExpression"
 							) {
+								warnings.push(
+									`${id}: export default <${declaration.type === "Identifier" ? "identifier" : declaration.type}> is not wrapped as an island — only function components are supported`,
+								);
 								return;
 							}
 
@@ -58,8 +86,20 @@ export const islands = (): Plugin[] => {
 						},
 						ExportNamedDeclaration(node) {
 							const declaration = node.declaration;
-							if (declaration?.type === "VariableDeclaration") {
-								const declarator = declaration.declarations[0];
+
+							if (!declaration) {
+								if (node.exportKind !== "type") {
+									warnings.push(
+										`${id}: export { … } statements are not wrapped as islands — export the component with \`export const\` or \`export function\``,
+									);
+								}
+								return;
+							}
+
+							if (declaration.type === "VariableDeclaration") {
+								const declarators = declaration.declarations;
+								const declarator = declarators[0];
+
 								if (
 									!declarator ||
 									declarator.id.type !== "Identifier" ||
@@ -68,7 +108,22 @@ export const islands = (): Plugin[] => {
 								) {
 									return;
 								}
+
 								const exportName = declarator.id.name;
+
+								if (!isWrappableInit(declarator.init)) {
+									warnings.push(
+										`${id}: export "${exportName}" does not look like a component — left as a plain export, not an island`,
+									);
+									return;
+								}
+
+								if (declarators.length > 1) {
+									warnings.push(
+										`${id}: only the first declarator of a multi-declarator export is wrapped as an island ("${exportName}") — split the declaration`,
+									);
+								}
+
 								seenExports.add(exportName);
 
 								// export const <name> = <init> ->
@@ -82,7 +137,7 @@ export const islands = (): Plugin[] => {
 									declarator.init.end,
 									`; export const ${exportName} = __runtime.createIsland(__wrap_${exportName}, "${exportName}", __assets)`,
 								);
-							} else if (declaration?.type === "FunctionDeclaration") {
+							} else if (declaration.type === "FunctionDeclaration") {
 								const fnId = declaration.id;
 								if (
 									!fnId ||
@@ -105,6 +160,10 @@ export const islands = (): Plugin[] => {
 							}
 						},
 					}).visit(program);
+
+					for (const warning of warnings) {
+						this.warn(warning);
+					}
 				}),
 			},
 		},
@@ -113,8 +172,9 @@ export const islands = (): Plugin[] => {
 			transform: {
 				order: "post",
 				handler: withMagicString(function (s) {
-					if (s.original.includes("__island_raw_import__")) {
-						s.replaceAll("__island_raw_import__", "import");
+					// the token is namespaced to avoid colliding with user code
+					if (s.original.includes("__yamf_raw_import__")) {
+						s.replaceAll("__yamf_raw_import__", "import");
 					}
 				}),
 			},

package/src/vite/prerender.ts

@@ -0,0 +1,27 @@
+import type { NitroModule } from "nitro/types";
+
+// Nitro's prerenderer is a standalone rolldown build (`nitro-prerender` preset)
+// that cannot run yamf's vite plugins, so `virtual:yamf:*` modules, the islands
+// transform, and the vite asset manifests do not exist there. Its auto-detected
+// serverEntry (src/server.tsx) would be bundled by rolldown and crash the
+// worker at init (`Received protocol 'virtual:'`). Disabling it lets prerender
+// requests fall through to the inherited renderer — nitro's vite ssr-renderer —
+// which dispatches them into the vite-built ssr service bundle: the exact code
+// path the production server uses.
+export const prerenderModule: NitroModule = {
+	name: "yamf:prerender",
+	setup(nitro) {
+		nitro.hooks.hook("prerender:config", config => {
+			config.serverEntry = false;
+		});
+
+		nitro.hooks.hook("prerender:generate", route => {
+			// static hosts (github-pages & friends) expect the not-found document
+			// at exactly /404.html; nitro would write /404 as 404/index.html
+			// (autoSubfolderIndex)
+			if (route.route === "/404" && !route.error && !route.skip) {
+				route.fileName = "404.html";
+			}
+		});
+	},
+};

package/src/vite/virtual-root.ts

@@ -1,3 +1,4 @@
+import { resolve } from "node:path";
 import { resolveModulePath } from "exsolve";
 import type { Plugin } from "vite";
 import { js } from "../shared/utils";
@@ -8,8 +9,15 @@ export const virtualRoot = (): Plugin => {
 	const virtualModuleId = "virtual:yamf:root";
 	const resolvedVirtualModuleId = "\0" + virtualModuleId;
 
+	// resolved against the vite root (not cwd) so running vite from another
+	// working directory does not silently skip the root layout
+	let root = process.cwd();
+
 	return {
 		name: "yamf:virtual-root",
+		configResolved(config) {
+			root = config.root;
+		},
 		resolveId(id) {
 			if (id === virtualModuleId) {
 				return resolvedVirtualModuleId;
@@ -22,13 +30,15 @@ export const virtualRoot = (): Plugin => {
 				return;
 			}
 
-			const root = resolveModulePath(ROOT_PATH, {
+			const rootPath = resolve(root, ROOT_PATH);
+
+			const rootModule = resolveModulePath(rootPath, {
 				try: true,
 				suffixes: ["", "/index"],
 				extensions: [".tsx", ".jsx", ".ts", ".js", ".mjs", ".cjs", ".mts", ".cts"],
 			});
 
-			if (!root) {
+			if (!rootModule) {
 				return js`
 const Root = null;
 const rootAssets = null;
@@ -38,8 +48,8 @@ export { Root, rootAssets };
 			}
 
 			return js`
-import Root from "${ROOT_PATH}";
-import rootAssets from "${ROOT_PATH}?assets=ssr";
+import Root from "${rootModule}";
+import rootAssets from "${rootModule}?assets=ssr";
 
 export { Root, rootAssets };
 `.trim();

package/src/vite/virtual-template.ts

@@ -1,5 +1,5 @@
 import { readFile } from "node:fs/promises";
-import { relative } from "node:path";
+import { isAbsolute, relative, resolve } from "node:path";
 import type { Plugin } from "vite";
 import { js } from "../shared/utils";
 
@@ -19,8 +19,16 @@ export const virtualTemplate = (): Plugin => {
 	const virtualModuleId = "virtual:yamf:template";
 	const resolvedVirtualModuleId = "\0" + virtualModuleId;
 
+	// resolved against the vite root (not cwd) so running vite from another
+	// working directory — monorepo tooling, turbo, etc — does not silently
+	// fall back to the default template
+	let root = process.cwd();
+
 	return {
 		name: "yamf:virtual-template",
+		configResolved(config) {
+			root = config.root;
+		},
 		resolveId(id) {
 			if (id === virtualModuleId) {
 				return resolvedVirtualModuleId;
@@ -34,7 +42,7 @@ export const virtualTemplate = (): Plugin => {
 			}
 
 			try {
-				const template = await readFile(TEMPLATE_PATH, "utf8");
+				const template = await readFile(resolve(root, TEMPLATE_PATH), "utf8");
 
 				return js`export const template = ${JSON.stringify(template)};`;
 			} catch (error) {
@@ -46,7 +54,11 @@ export const virtualTemplate = (): Plugin => {
 			}
 		},
 		handleHotUpdate({ file, server }) {
-			if (relative(file, TEMPLATE_PATH) === "") {
+			if (!isAbsolute(file)) {
+				return;
+			}
+
+			if (relative(resolve(root, TEMPLATE_PATH), file) === "") {
 				const mod = server.moduleGraph.getModuleById(resolvedVirtualModuleId);
 
 				if (mod) {