@sveltejs/kit 3.0.0-next.1 → 3.0.0-next.3

package/src/runtime/server/page/render.js

@@ -20,9 +20,9 @@ import {
 	get_global_name,
 	handle_error_and_jsonify
 } from '../utils.js';
-import { create_remote_key } from '../../shared.js';
 import { get_status } from '../../../utils/error.js';
 import * as env from '__sveltekit/env';
+import { collect_remote_data } from '../remote.js';
 
 // TODO rename this function/module
 
@@ -78,9 +78,9 @@ export async function render_response({
 
 	const { client } = manifest._;
 
-	const modulepreloads = new Set(client.imports);
-	const stylesheets = new Set(client.stylesheets);
-	const fonts = new Set(client.fonts);
+	const modulepreloads = new Set(client?.imports);
+	const stylesheets = new Set(client?.stylesheets);
+	const fonts = new Set(client?.fonts);
 
 	/**
 	 * The value of the Link header that is added to the response when not prerendering
@@ -281,7 +281,7 @@ export async function render_response({
 		for (const url of node.stylesheets) stylesheets.add(url);
 		for (const url of node.fonts) fonts.add(url);
 
-		if (node.inline_styles && !client.inline) {
+		if (node.inline_styles && !client?.inline) {
 			Object.entries(await node.inline_styles()).forEach(([filename, css]) => {
 				if (typeof css === 'string') {
 					inline_styles.set(filename, css);
@@ -307,7 +307,7 @@ export async function render_response({
 		return `${assets}/${path}`;
 	};
 
-	const style = client.inline
+	const style = client?.inline
 		? client.inline?.style
 		: Array.from(inline_styles.values()).join('\n');
 
@@ -371,8 +371,8 @@ export async function render_response({
 			.join('\n\t\t\t')}`;
 	}
 
-	if (page_config.csr) {
-		const route = manifest._.client.routes?.find((r) => r.id === event.route.id) ?? null;
+	if (page_config.csr && client) {
+		const route = client.routes?.find((r) => r.id === event.route.id) ?? null;
 
 		if (client.uses_env_dynamic_public && state.prerendering) {
 			modulepreloads.add(`${paths.app_dir}/env.js`);
@@ -400,12 +400,12 @@ export async function render_response({
 		}
 
 		// prerender a `/path/to/page/__route.js` module
-		if (manifest._.client.routes && state.prerendering && !state.prerendering.fallback) {
+		if (client.routes && state.prerendering && !state.prerendering.fallback) {
 			const pathname = add_resolution_suffix(event.url.pathname);
 
 			state.prerendering.dependencies.set(
 				pathname,
-				create_server_routing_response(route, event.params, new URL(pathname, event.url), manifest)
+				create_server_routing_response(route, event.params, new URL(pathname, event.url), client)
 			);
 		}
 
@@ -505,9 +505,9 @@ export async function render_response({
 				hydrate.push(`status: ${status}`);
 			}
 
-			if (manifest._.client.routes) {
+			if (client.routes) {
 				if (route) {
-					const stringified = generate_route_object(route, event.url, manifest).replaceAll(
+					const stringified = generate_route_object(route, event.url, client).replaceAll(
 						'\n',
 						'\n\t\t\t\t\t\t\t'
 					); // make output after it's put together with the rest more readable
@@ -521,87 +521,27 @@ export async function render_response({
 			args.push(`{\n${indent}\t${hydrate.join(`,\n${indent}\t`)}\n${indent}}`);
 		}
 
-		const { remote } = event_state;
-
-		let serialized_query_data = '';
-		let serialized_prerender_data = '';
-
-		if (remote.data) {
-			/** @type {Record<string, any>} */
-			const query = {};
-
-			/** @type {Record<string, any>} */
-			const prerender = {};
-
-			for (const [internals, cache] of remote.data) {
-				// remote functions without an `id` aren't exported, and thus
-				// cannot be called from the client
-				if (!internals.id) continue;
-
-				for (const key in cache) {
-					const entry = cache[key];
-
-					if (!entry.serialize) continue;
-
-					const remote_key = create_remote_key(internals.id, key);
-
-					const store = internals.type === 'prerender' ? prerender : query;
-
-					if (
-						event_state.remote.refreshes?.has(remote_key) ||
-						event_state.remote.reconnects?.has(remote_key)
-					) {
-						// This entry was refreshed/set by a command or form action.
-						// Always await it so the mutation result is serialized.
-						store[remote_key] = await entry.data;
-					} else {
-						// Don't block the response on pending remote data - if a query
-						// hasn't settled yet, it wasn't awaited in the template (or is behind a pending boundary).
-						const result = await Promise.race([
-							Promise.resolve(entry.data).then(
-								(v) => /** @type {const} */ ({ settled: true, value: v }),
-								(e) => /** @type {const} */ ({ settled: true, error: e })
-							),
-							new Promise((resolve) => {
-								queueMicrotask(() => resolve(/** @type {const} */ ({ settled: false })));
-							})
-						]);
-
-						if (result.settled) {
-							if ('error' in result) throw result.error;
-							store[remote_key] = result.value;
-						}
-					}
-				}
-			}
-
-			const replacer = create_replacer(options.hooks.transport);
-
-			if (Object.keys(query).length > 0) {
-				serialized_query_data = `${global}.query = ${devalue.uneval(query, replacer)};\n\n\t\t\t\t\t\t`;
-			}
-
-			if (Object.keys(prerender).length > 0) {
-				serialized_prerender_data = `${global}.prerender = ${devalue.uneval(prerender, replacer)};\n\n\t\t\t\t\t\t`;
-			}
-		}
+		const remote_data = await collect_remote_data({}, event, event_state, options);
 
-		const serialized_remote_data = `${serialized_query_data}${serialized_prerender_data}`;
+		const serialized_data =
+			Object.keys(remote_data).length > 0
+				? `${global}.data = ${devalue.uneval(remote_data, create_replacer(options.hooks.transport))};\n\n\t\t\t\t\t\t`
+				: '';
 
 		// `client.app` is a proxy for `bundleStrategy === 'split'`
 		const boot = client.inline
 			? `${client.inline.script}
 
-					${serialized_remote_data}${global}.app.start(${args.join(', ')});`
+					${serialized_data}${global}.app.start(${args.join(', ')});`
 			: client.app
 				? `Promise.all([
 						import(${s(prefixed(client.start))}),
 						import(${s(prefixed(client.app))})
 					]).then(([kit, app]) => {
-						${serialized_remote_data}kit.start(app, ${args.join(', ')});
+						${serialized_data}kit.start(app, ${args.join(', ')});
 					});`
 				: `import(${s(prefixed(client.start))}).then((app) => {
-						${serialized_remote_data}app.start(${args.join(', ')})
+						${serialized_data}app.start(${args.join(', ')})
 					});`;
 
 		if (load_env_eagerly) {
@@ -639,8 +579,11 @@ export async function render_response({
 					}`);
 		}
 
+		// we need to eagerly import the Vite client module in development to ensure
+		// that Vite global constant replacements are initialised before our code runs
 		const init_app = `
 				{
+					${DEV ? `import('${paths.base}/@vite/client')` : ''}
 					${blocks.join('\n\n\t\t\t\t\t')}
 				}
 			`;

package/src/runtime/server/page/server_routing.js

@@ -1,3 +1,4 @@
+/** @import { SSRManifest } from '@sveltejs/kit' */
 import { base, assets, relative } from '$app/paths/internal/server';
 import { text } from '@sveltejs/kit';
 import { s } from '../../../utils/misc.js';
@@ -7,15 +8,15 @@ import { get_relative_path } from '../../utils.js';
 /**
  * @param {import('types').SSRClientRoute} route
  * @param {URL} url
- * @param {import('@sveltejs/kit').SSRManifest} manifest
+ * @param {NonNullable<SSRManifest['_']['client']>} client
  * @returns {string}
  */
-export function generate_route_object(route, url, manifest) {
+export function generate_route_object(route, url, client) {
 	const { errors, layouts, leaf } = route;
 
 	const nodes = [...errors, ...layouts.map((l) => l?.[1]), leaf[1]]
 		.filter((n) => typeof n === 'number')
-		.map((n) => `'${n}': () => ${create_client_import(manifest._.client.nodes?.[n], url)}`)
+		.map((n) => `'${n}': () => ${create_client_import(client.nodes?.[n], url)}`)
 		.join(',\n\t\t');
 
 	// stringified version of
@@ -60,36 +61,40 @@ function create_client_import(import_path, url) {
 /**
  * @param {string} resolved_path
  * @param {URL} url
- * @param {import('@sveltejs/kit').SSRManifest} manifest
+ * @param {SSRManifest} manifest
  * @returns {Promise<Response>}
  */
 export async function resolve_route(resolved_path, url, manifest) {
-	if (!manifest._.client.routes) {
+	if (!manifest._.client?.routes) {
 		return text('Server-side route resolution disabled', { status: 400 });
 	}
 
 	const matchers = await manifest._.matchers();
 	const result = find_route(resolved_path, manifest._.client.routes, matchers);
 
-	return create_server_routing_response(result?.route ?? null, result?.params ?? {}, url, manifest)
-		.response;
+	return create_server_routing_response(
+		result?.route ?? null,
+		result?.params ?? {},
+		url,
+		manifest._.client
+	).response;
 }
 
 /**
  * @param {import('types').SSRClientRoute | null} route
  * @param {Partial<Record<string, string>>} params
  * @param {URL} url
- * @param {import('@sveltejs/kit').SSRManifest} manifest
+ * @param {NonNullable<SSRManifest['_']['client']>} client
  * @returns {{response: Response, body: string}}
  */
-export function create_server_routing_response(route, params, url, manifest) {
+export function create_server_routing_response(route, params, url, client) {
 	const headers = new Headers({
 		'content-type': 'application/javascript; charset=utf-8'
 	});
 
 	if (route) {
-		const csr_route = generate_route_object(route, url, manifest);
-		const body = `${create_css_import(route, url, manifest)}\nexport const route = ${csr_route}; export const params = ${JSON.stringify(params)};`;
+		const csr_route = generate_route_object(route, url, client);
+		const body = `${create_css_import(route, url, client)}\nexport const route = ${csr_route}; export const params = ${JSON.stringify(params)};`;
 
 		return { response: text(body, { headers }), body };
 	} else {
@@ -105,17 +110,17 @@ export function create_server_routing_response(route, params, url, manifest) {
  *
  * @param {import('types').SSRClientRoute} route
  * @param {URL} url
- * @param {import('@sveltejs/kit').SSRManifest} manifest
+ * @param {NonNullable<SSRManifest['_']['client']>} client
  * @returns {string}
  */
-function create_css_import(route, url, manifest) {
+function create_css_import(route, url, client) {
 	const { errors, layouts, leaf } = route;
 
 	let css = '';
 
 	for (const node of [...errors, ...layouts.map((l) => l?.[1]), leaf[1]]) {
 		if (typeof node !== 'number') continue;
-		const node_css = manifest._.client.css?.[node];
+		const node_css = client.css?.[node];
 		for (const css_path of node_css ?? []) {
 			css += `'${assets || base}/${css_path}',`;
 		}
@@ -123,5 +128,5 @@ function create_css_import(route, url, manifest) {
 
 	if (!css) return '';
 
-	return `${create_client_import(/** @type {string} */ (manifest._.client.start), url)}.then(x => x.load_css([${css}]));`;
+	return `${create_client_import(client.start, url)}.then(x => x.load_css([${css}]));`;
 }