@sveltejs/kit 2.54.0 → 2.56.0

package/src/runtime/client/remote-functions/prerender.svelte.js

@@ -1,13 +1,11 @@
+/** @import { RemotePrerenderFunction } from '@sveltejs/kit' */
 import { app_dir, base } from '$app/paths/internal/client';
 import { version } from '__sveltekit/environment';
 import * as devalue from 'devalue';
 import { DEV } from 'esm-env';
-import { app, remote_responses } from '../client.js';
-import {
-	create_remote_function,
-	get_remote_request_headers,
-	remote_request
-} from './shared.svelte.js';
+import { app, prerender_responses } from '../client.js';
+import { get_remote_request_headers, remote_request } from './shared.svelte.js';
+import { create_remote_key, stringify_remote_arg } from '../../shared.js';
 
 // Initialize Cache API for prerender functions
 const CACHE_NAME = DEV ? `sveltekit:${Date.now()}` : `sveltekit:${version}`;
@@ -32,9 +30,105 @@ const prerender_cache_ready = (async () => {
 	}
 })();
 
+/**
+ * @param {string} url
+ * @param {string} encoded
+ */
+function put(url, encoded) {
+	return /** @type {Cache} */ (prerender_cache)
+		.put(
+			url,
+			// We need to create a new response because the original response is already consumed
+			new Response(encoded, {
+				headers: {
+					'Content-Type': 'application/json'
+				}
+			})
+		)
+		.catch(() => {
+			// Nothing we can do here
+		});
+}
+
+/**
+ * @param {string} id
+ * @returns {RemotePrerenderFunction<any, any>}
+ */
+export function prerender(id) {
+	return (arg) => {
+		const payload = stringify_remote_arg(arg, app.hooks.transport);
+		const cache_key = create_remote_key(id, payload);
+
+		let resource = prerender_resources.get(cache_key)?.deref();
+
+		if (!resource) {
+			resource = new Prerender(async () => {
+				await prerender_cache_ready;
+
+				const url = `${base}/${app_dir}/remote/${id}${payload ? `/${payload}` : ''}`;
+
+				if (Object.hasOwn(prerender_responses, cache_key)) {
+					const data = prerender_responses[cache_key];
+
+					if (prerender_cache) {
+						void put(url, devalue.stringify(data, app.encoders));
+					}
+
+					return data;
+				}
+
+				// Do this here, after await Svelte' reactivity context is gone.
+				const headers = get_remote_request_headers();
+
+				// Check the Cache API first
+				if (prerender_cache) {
+					try {
+						const cached_response = await prerender_cache.match(url);
+
+						if (cached_response) {
+							const cached_result = await cached_response.text();
+							return devalue.parse(cached_result, app.decoders);
+						}
+					} catch {
+						void prerender_cache.delete(url);
+					}
+				}
+
+				const encoded = await remote_request(url, headers);
+
+				// For successful prerender requests, save to cache
+				if (prerender_cache) {
+					void put(url, encoded);
+				}
+
+				return devalue.parse(encoded, app.decoders);
+			});
+
+			prerender_resources.set(cache_key, new WeakRef(resource));
+			prerender_resource_cleanup?.register(resource, cache_key);
+		}
+
+		return resource;
+	};
+}
+
+/** @type {Map<string, WeakRef<Prerender<any>>>} */
+const prerender_resources = new Map();
+
+/** @type {FinalizationRegistry<string> | null} */
+const prerender_resource_cleanup =
+	typeof FinalizationRegistry === 'undefined'
+		? null
+		: new FinalizationRegistry((cache_key) => {
+				const ref = prerender_resources.get(cache_key);
+				if (ref && ref.deref() === undefined) {
+					prerender_resources.delete(cache_key);
+				}
+			});
+
 /**
  * @template T
- * @implements {Partial<Promise<T>>}
+ * @implements {Promise<T>}
  */
 class Prerender {
 	/** @type {Promise<T>} */
@@ -42,7 +136,6 @@ class Prerender {
 
 	#loading = $state(true);
 	#ready = $state(false);
-
 	/** @type {T | undefined} */
 	#current = $state.raw();
 
@@ -57,6 +150,7 @@ class Prerender {
 				this.#loading = false;
 				this.#ready = true;
 				this.#current = value;
+				this.#error = undefined;
 				return value;
 			},
 			(error) => {
@@ -112,73 +206,8 @@ class Prerender {
 	get ready() {
 		return this.#ready;
 	}
-}
-
-/**
- * @param {string} url
- * @param {string} encoded
- */
-function put(url, encoded) {
-	return /** @type {Cache} */ (prerender_cache)
-		.put(
-			url,
-			// We need to create a new response because the original response is already consumed
-			new Response(encoded, {
-				headers: {
-					'Content-Type': 'application/json'
-				}
-			})
-		)
-		.catch(() => {
-			// Nothing we can do here
-		});
-}
 
-/**
- * @param {string} id
- */
-export function prerender(id) {
-	return create_remote_function(id, (cache_key, payload) => {
-		return new Prerender(async () => {
-			await prerender_cache_ready;
-
-			const url = `${base}/${app_dir}/remote/${id}${payload ? `/${payload}` : ''}`;
-
-			if (Object.hasOwn(remote_responses, cache_key)) {
-				const data = remote_responses[cache_key];
-
-				if (prerender_cache) {
-					void put(url, devalue.stringify(data, app.encoders));
-				}
-
-				return data;
-			}
-
-			// Do this here, after await Svelte' reactivity context is gone.
-			const headers = get_remote_request_headers();
-
-			// Check the Cache API first
-			if (prerender_cache) {
-				try {
-					const cached_response = await prerender_cache.match(url);
-
-					if (cached_response) {
-						const cached_result = await cached_response.text();
-						return devalue.parse(cached_result, app.decoders);
-					}
-				} catch {
-					// Nothing we can do here
-				}
-			}
-
-			const encoded = await remote_request(url, headers);
-
-			// For successful prerender requests, save to cache
-			if (prerender_cache) {
-				void put(url, encoded);
-			}
-
-			return devalue.parse(encoded, app.decoders);
-		});
-	});
+	get [Symbol.toStringTag]() {
+		return 'Prerender';
+	}
 }