vorma 0.83.0 → 0.85.0-pre.0

package/internal/framework/_typescript/client/src/links.ts

@@ -1,5 +1,6 @@
 import { getAnchorDetailsFromEvent, getHrefDetails } from "vorma/kit/url";
 import { navigationStateManager, vormaNavigate } from "./client.ts";
+import { effectuateRedirectDataResult } from "./redirects/redirects.ts";
 import { saveScrollState } from "./scroll_state_manager.ts";
 
 type LinkOnClickCallback<E extends Event> = (event: E) => void | Promise<void>;
@@ -173,29 +174,62 @@ export function __makeLinkOnClickFn<E extends Event>(
 
 			if (!control.promise) return;
 
-			const res = await control.promise;
-
-			if (!res) {
-				// If not here, loading indicator can get stuck on
-				// following redirects
-				const targetUrl = new URL(anchor.href, window.location.href)
-					.href;
-				navigationStateManager.removeNavigation(targetUrl);
-				return;
-			}
-
-			await callbacks.beforeRender?.(e);
-
+			const outcome = await control.promise;
 			const targetUrl = new URL(anchor.href, window.location.href).href;
-			const entry = navigationStateManager.getNavigation(targetUrl);
-			if (entry) {
-				await navigationStateManager["processNavigationResult"](
-					res,
-					entry,
-				);
-			}
 
-			await callbacks.afterRender?.(e);
+			// Handle outcome based on type (discriminated union)
+			switch (outcome.type) {
+				case "aborted":
+					// Navigation was aborted - clean up to prevent stuck loading indicator
+					navigationStateManager.removeNavigation(targetUrl);
+					return;
+
+				case "redirect": {
+					// Call beforeRender while entry still exists (consistent with success case)
+					await callbacks.beforeRender?.(e);
+
+					// Clean up before redirect to prevent race conditions
+					navigationStateManager.removeNavigation(targetUrl);
+
+					// Effectuate the redirect
+					await effectuateRedirectDataResult(
+						outcome.redirectData,
+						outcome.props.redirectCount || 0,
+						outcome.props,
+					);
+
+					// Call afterRender after redirect effectuation
+					await callbacks.afterRender?.(e);
+					return;
+				}
+
+				case "success": {
+					// Call beforeRender before processing (matches original behavior)
+					await callbacks.beforeRender?.(e);
+
+					// Process the successful navigation if entry still exists
+					const entry =
+						navigationStateManager.getNavigation(targetUrl);
+					if (entry) {
+						await navigationStateManager.processSuccessfulNavigation(
+							outcome,
+							entry,
+						);
+					}
+
+					// Call afterRender after processing (matches original behavior)
+					await callbacks.afterRender?.(e);
+					return;
+				}
+
+				default: {
+					// Exhaustiveness check
+					const _exhaustive: never = outcome;
+					throw new Error(
+						`Unexpected outcome type: ${(_exhaustive as any).type}`,
+					);
+				}
+			}
 		}
 	};
 }

package/internal/framework/_typescript/create/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "create-vorma",
-	"version": "0.83.0",
+	"version": "0.85.0-pre.0",
 	"description": "CLI for creating new Vorma applications.",
 	"type": "module",
 	"license": "BSD-3-Clause",
@@ -24,8 +24,8 @@
 		"@clack/prompts": "^0.11.0"
 	},
 	"devDependencies": {
-		"@types/node": "^24.2.1",
-		"typescript": "^5.9.2"
+		"@types/node": "^24.10.7",
+		"typescript": "^5.9.3"
 	},
 	"engines": {
 		"node": ">=22.11.0"

package/internal/framework/_typescript/create/pnpm-lock.yaml

@@ -13,11 +13,11 @@ importers:
         version: 0.11.0
     devDependencies:
       '@types/node':
-        specifier: ^24.2.1
-        version: 24.2.1
+        specifier: ^24.10.7
+        version: 24.10.7
       typescript:
-        specifier: ^5.9.2
-        version: 5.9.2
+        specifier: ^5.9.3
+        version: 5.9.3
 
 packages:
 
@@ -27,8 +27,8 @@ packages:
   '@clack/prompts@0.11.0':
     resolution: {integrity: sha512-pMN5FcrEw9hUkZA4f+zLlzivQSeQf5dRGJjSUbvVYDLvpKCdQx5OaknvKzgbtXOizhP+SJJJjqEbOe55uKKfAw==}
 
-  '@types/node@24.2.1':
-    resolution: {integrity: sha512-DRh5K+ka5eJic8CjH7td8QpYEV6Zo10gfRkjHCO3weqZHWDtAaSTFtl4+VMqOJ4N5jcuhZ9/l+yy8rVgw7BQeQ==}
+  '@types/node@24.10.7':
+    resolution: {integrity: sha512-+054pVMzVTmRQV8BhpGv3UyfZ2Llgl8rdpDTon+cUH9+na0ncBVXj3wTUKh14+Kiz18ziM3b4ikpP5/Pc0rQEQ==}
 
   picocolors@1.1.1:
     resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
@@ -36,13 +36,13 @@ packages:
   sisteransi@1.0.5:
     resolution: {integrity: sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==}
 
-  typescript@5.9.2:
-    resolution: {integrity: sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A==}
+  typescript@5.9.3:
+    resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==}
     engines: {node: '>=14.17'}
     hasBin: true
 
-  undici-types@7.10.0:
-    resolution: {integrity: sha512-t5Fy/nfn+14LuOc2KNYg75vZqClpAiqscVvMygNnlsHBFpSXdJaYtXMcdNLpl/Qvc3P2cB3s6lOV51nqsFq4ag==}
+  undici-types@7.16.0:
+    resolution: {integrity: sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==}
 
 snapshots:
 
@@ -57,14 +57,14 @@ snapshots:
       picocolors: 1.1.1
       sisteransi: 1.0.5
 
-  '@types/node@24.2.1':
+  '@types/node@24.10.7':
     dependencies:
-      undici-types: 7.10.0
+      undici-types: 7.16.0
 
   picocolors@1.1.1: {}
 
   sisteransi@1.0.5: {}
 
-  typescript@5.9.2: {}
+  typescript@5.9.3: {}
 
-  undici-types@7.10.0: {}
+  undici-types@7.16.0: {}

package/internal/framework/_typescript/vite/vite.ts

@@ -1,23 +1,74 @@
+import { readFileSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+
 type VormaVitePluginConfig = {
 	rollupInput: ReadonlyArray<string>;
 	publicPathPrefix: string;
 	staticPublicAssetMap: Record<string, string>;
 	buildtimePublicURLFuncName: string;
+	filemapJSONPath: string;
 	ignoredPatterns: ReadonlyArray<string>;
 	dedupeList: ReadonlyArray<string>;
 };
 
 export default function vormaVitePlugin(config: VormaVitePluginConfig): any {
+	// Cache for dev mode filemap reading.
+	// In dev mode, we read from the JSON file so we can pick up changes
+	// without restarting Vite. The mtime check allows us to avoid re-reading
+	// the file on every transform if it hasn't changed.
+	let cachedMap: Record<string, string> | null = null;
+	let cachedMtime: number = 0;
+	let isDev = false;
+	let resolvedFilemapPath: string | null = null;
+
+	/**
+	 * Gets the current filemap, reading from disk in dev mode.
+	 * In production builds, uses the static map passed at plugin creation.
+	 */
+	function getFilemap(): Record<string, string> {
+		if (!isDev) {
+			return config.staticPublicAssetMap;
+		}
+
+		if (!resolvedFilemapPath) {
+			resolvedFilemapPath = resolve(
+				process.cwd(),
+				config.filemapJSONPath,
+			);
+		}
+
+		try {
+			const stat = statSync(resolvedFilemapPath);
+			const mtime = stat.mtimeMs;
+
+			// Return cached version if file hasn't changed
+			if (cachedMap && mtime === cachedMtime) {
+				return cachedMap;
+			}
+
+			const content = readFileSync(resolvedFilemapPath, "utf-8");
+			cachedMap = JSON.parse(content);
+			cachedMtime = mtime;
+			return cachedMap!;
+		} catch {
+			// Fallback to initial config if file can't be read.
+			// This handles the case where the JSON file doesn't exist yet
+			// (e.g., on first build before Wave has written it).
+			return config.staticPublicAssetMap;
+		}
+	}
+
 	return {
 		name: "vorma-vite-plugin",
+
 		config(c: any, { command }: any) {
+			isDev = command === "serve";
+
 			const mp = c.build?.modulePreload;
 			const roi = c.build?.rollupOptions?.input;
 			const ign = c.server?.watch?.ignored;
 			const dedupe = c.resolve?.dedupe;
 
-			const isDev = command === "serve";
-
 			return {
 				base: isDev ? "/" : config.publicPathPrefix,
 				build: {
@@ -65,6 +116,48 @@ export default function vormaVitePlugin(config: VormaVitePluginConfig): any {
 				},
 			};
 		},
+
+		/**
+		 * Configures the dev server with an endpoint for filemap cache invalidation.
+		 * Wave calls this endpoint after updating public static files, which:
+		 * 1. Clears the cached filemap so the next transform reads fresh data
+		 * 2. Invalidates all modules in Vite's module graph
+		 * 3. Triggers a browser reload via Vite's HMR websocket
+		 *
+		 * This is much faster than cycling Vite (stopping and restarting the process).
+		 */
+		configureServer(server: any) {
+			server.middlewares.use((req: any, res: any, next: any) => {
+				if (req.url !== "/__vorma_invalidate_filemap") {
+					return next();
+				}
+
+				console.log(
+					"[vorma-vite-plugin] Filemap invalidation triggered",
+				);
+
+				// Clear the filemap cache so the next transform reads fresh data
+				cachedMap = null;
+				cachedMtime = 0;
+
+				// Invalidate all modules in Vite's module graph.
+				// This is simpler than tracking which specific modules use
+				// waveBuildtimeURL() and fast enough for typical project sizes
+				// (a few ms for hundreds of modules).
+				for (const mod of server.moduleGraph.idToModuleMap.values()) {
+					server.moduleGraph.invalidateModule(mod);
+				}
+
+				// Trigger a full browser reload via Vite's HMR websocket.
+				// The browser will re-request modules, Vite will re-transform them
+				// (cache miss due to invalidation), and they'll get the new URLs.
+				server.ws.send({ type: "full-reload" });
+
+				res.statusCode = 200;
+				res.end("ok");
+			});
+		},
+
 		transform(code: any, id: any) {
 			const isNodeModules = /node_modules/.test(id);
 			if (isNodeModules) return null;
@@ -77,10 +170,13 @@ export default function vormaVitePlugin(config: VormaVitePluginConfig): any {
 			const needsReplacement = regex.test(code);
 			if (!needsReplacement) return null;
 
+			// Get the current filemap (reads from disk in dev mode)
+			const filemap = getFilemap();
+
 			const replacedCode = code.replace(
 				regex,
 				(_: any, __: any, assetPath: any) => {
-					const hashed = config.staticPublicAssetMap[assetPath];
+					const hashed = filemap[assetPath];
 					if (!hashed) return `"${assetPath}"`;
 					return `"${config.publicPathPrefix}${hashed}"`;
 				},