@sveltejs/kit 3.0.0-next.23 → 3.0.0-next.25

package/src/exports/node/index.js

@@ -116,12 +116,13 @@ function get_raw_body(req, body_size_limit) {
 /**
  * @param {{
  *   request: import('http').IncomingMessage;
+ *   response?: import('http').ServerResponse;
  *   base: string;
  *   bodySizeLimit?: number;
  * }} options
  * @returns {Request}
  */
-export function getRequest({ request, base, bodySizeLimit }) {
+export function getRequest({ request, response, base, bodySizeLimit }) {
 	let headers = /** @type {Record<string, string>} */ (request.headers);
 	if (request.httpVersionMajor >= 2) {
 		// the Request constructor rejects headers with ':' in the name
@@ -144,6 +145,15 @@ export function getRequest({ request, base, bodySizeLimit }) {
 		}
 	});
 
+	// `readableAborted` stays false once the request has been fully read (or drained),
+	// so a client disconnect must also be detected on the response side. `writableEnded`
+	// rather than `writableFinished` because HTTP/2 marks cancelled streams as finished
+	response?.once('close', () => {
+		if (!response.writableEnded) {
+			controller.abort();
+		}
+	});
+
 	return new Request(base + request.url, {
 		// @ts-expect-error
 		duplex: 'half',
@@ -214,14 +224,14 @@ export function setResponse(res, response) {
 		}
 	}
 
-	res.writeHead(response.status);
-
 	if (!response.body) {
+		res.writeHead(response.status);
 		res.end();
 		return;
 	}
 
 	if (response.body.locked) {
+		res.writeHead(response.status);
 		res.end(
 			'Fatal error: Response body is locked. ' +
 				"This can happen when the response was already read (for example through 'response.json()' or 'response.text()')."
@@ -249,11 +259,73 @@ export function setResponse(res, response) {
 	res.on('close', cancel);
 	res.on('error', cancel);
 
-	void next();
+	/** @type {Uint8Array<ArrayBuffer>[]} */
+	const buffered = [];
+
+	/** @type {ReturnType<typeof reader.read> | null} */
+	let pending = null;
+
+	void probe();
+
+	// a fixed body (a string, buffer or blob, however constructed) settles all its
+	// reads before the next macrotask, so it can be measured and sent with a
+	// `content-length`; a genuine stream leaves a read pending and only has its
+	// headers delayed by a single tick
+	async function probe() {
+		try {
+			/** @type {Promise<undefined>} */
+			const deadline = new Promise((fulfil) => setImmediate(() => fulfil(undefined)));
+
+			while (buffered.length < 2) {
+				pending = reader.read();
+				const result = await Promise.race([pending, deadline]);
+
+				if (!result) break; // deadline hit — treat the body as a stream
+
+				pending = null;
+
+				if (result.done) {
+					// a `content-length` next to a `transfer-encoding` would be invalid
+					if (!res.hasHeader('content-length') && !res.hasHeader('transfer-encoding')) {
+						res.setHeader(
+							'content-length',
+							buffered.reduce((total, chunk) => total + chunk.byteLength, 0)
+						);
+					}
+					break;
+				}
+
+				buffered.push(result.value);
+			}
+
+			if (res.destroyed) return;
+
+			res.writeHead(response.status);
+			await next();
+		} catch (error) {
+			if (!res.headersSent) res.writeHead(response.status);
+			cancel(error instanceof Error ? error : new Error(String(error)));
+		}
+	}
+
 	async function next() {
 		try {
 			for (;;) {
-				const { done, value } = await reader.read();
+				/** @type {Awaited<ReturnType<typeof reader.read>>} */
+				let result;
+				if (buffered.length > 0) {
+					result = {
+						done: false,
+						value: /** @type {Uint8Array<ArrayBuffer>} */ (buffered.shift())
+					};
+				} else if (pending) {
+					result = await pending;
+					pending = null;
+				} else {
+					result = await reader.read();
+				}
+
+				const { done, value } = result;
 
 				if (done) break;
 

package/src/exports/public.d.ts

@@ -165,7 +165,7 @@ export interface Builder {
 	/**
 	 * Generate a server-side manifest to initialise the SvelteKit [server](https://svelte.dev/docs/kit/@sveltejs-kit#Server) with.
 	 * @param opts
-	 * @param opts.relativePath  A relative path to the base directory of the server build output
+	 * @param opts.relativePath A relative path to the base directory of the server build output
 	 */
 	generateManifest: (opts: { relativePath: string; routes?: RouteDefinition[] }) => string;
 

package/src/exports/vite/build/build_server.js

@@ -128,7 +128,7 @@ export function build_server_nodes(
 		/** @type {string[]} */
 		let stylesheets = [];
 
-		/** @type {string[]} */
+		/** @type {import('types').FontDependency[]} */
 		let fonts = [];
 
 		/** @type {Set<string>} */
@@ -187,7 +187,7 @@ export function build_server_nodes(
 			}
 
 			if (client_manifest) {
-				const entry_path = `${out_dir}/generated/client-optimized/nodes/${i}.js`;
+				const entry_path = `${out_dir}/generated/build/client-optimized/nodes/${i}.js`;
 				const entry = find_deps(client_manifest, entry_path, true, root);
 
 				// Eagerly load client stylesheets and fonts imported by the SSR-ed page to avoid FOUC.
@@ -212,7 +212,7 @@ export function build_server_nodes(
 
 				imported = entry.imports;
 				stylesheets = Array.from(eager_css);
-				fonts = filter_fonts(Array.from(eager_assets));
+				fonts = filter_fonts(Array.from(eager_assets), client_manifest, root);
 			} else {
 				for (const entry of [component, universal]) {
 					if (!entry) continue;

package/src/exports/vite/build/service-worker.js

@@ -0,0 +1,98 @@
+/** @import { ValidatedConfig } from 'types' */
+/** @import { Plugin, UserConfig } from 'vite' */
+import { runtime_directory } from '../../../core/utils.js';
+import { warn_overridden_config } from '../utils.js';
+
+/**
+ * @param {ValidatedConfig} kit
+ * @param {() => { service_worker_entry_file: string | null; kit_global: string; out: string; initial_config: UserConfig; }} get_config
+ * @returns {Plugin}
+ */
+export function plugin_service_worker_build(kit, get_config) {
+	return {
+		name: 'vite-plugin-sveltekit-service-worker',
+
+		config(config) {
+			const { service_worker_entry_file, kit_global, out, initial_config } = get_config();
+
+			if (!service_worker_entry_file) return;
+
+			if (kit.paths.assets) {
+				throw new Error('Cannot use service worker alongside config.paths.assets');
+			}
+
+			const user_service_worker_output_config =
+				config.environments?.serviceWorker?.build?.rolldownOptions?.output;
+
+			/** @type {UserConfig} */
+			const new_config = {
+				environments: {
+					serviceWorker: {
+						define: {
+							__SVELTEKIT_PAYLOAD__: kit_global
+						},
+						build: {
+							modulePreload: false,
+							rolldownOptions: {
+								external: [`${kit.paths.base}/${kit.appDir}/env.js`],
+								input: {
+									'service-worker': service_worker_entry_file
+								},
+								output: {
+									format: 'es',
+									entryFileNames: 'service-worker.js',
+									assetFileNames: `${kit.appDir}/immutable/assets/[name].[hash][extname]`,
+									codeSplitting:
+										(Array.isArray(user_service_worker_output_config)
+											? user_service_worker_output_config[0].codeSplitting
+											: user_service_worker_output_config?.codeSplitting) ?? false
+								}
+							},
+							outDir: `${out}/client`,
+							minify: initial_config.build?.minify,
+							// avoid overwriting the client build Vite manifest
+							manifest: '.vite/service-worker-manifest.json'
+						},
+						consumer: 'client'
+					}
+				}
+			};
+
+			warn_overridden_config(config, new_config);
+
+			return new_config;
+		},
+
+		// our serviceWorker environment only exists when building because Vite only
+		// supports the default client environment during development (for now)
+		applyToEnvironment(environment) {
+			return environment.name === 'serviceWorker';
+		},
+
+		generateBundle(_, bundle) {
+			const invalid_modules = new Set();
+			const modules = new Map([
+				[`${runtime_directory}/app/forms/index.js`, '$app/forms'],
+				[`${runtime_directory}/app/navigation/index.js`, '$app/navigation'],
+				[`${runtime_directory}/app/state/index.js`, '$app/state']
+			]);
+
+			for (const output of Object.values(bundle)) {
+				if (output.type !== 'chunk') continue;
+
+				for (const id of output.moduleIds) {
+					const module = modules.get(id);
+					if (module) invalid_modules.add(module);
+				}
+			}
+
+			if (invalid_modules.size > 0) {
+				throw new Error(
+					`Cannot import ${Array.from(modules.values())
+						.filter((module) => invalid_modules.has(module))
+						.join(', ')} into service-worker code.`
+				);
+			}
+		}
+	};
+}

package/src/exports/vite/build/utils.js

@@ -94,7 +94,7 @@ export function find_deps(manifest, entry, add_dynamic_css, root) {
 		imports: Array.from(imports),
 		stylesheets: Array.from(stylesheets),
 		// TODO do we need this separately?
-		fonts: filter_fonts(assets),
+		fonts: filter_fonts(assets, manifest, root),
 		stylesheet_map
 	};
 }
@@ -116,12 +116,56 @@ export function resolve_symlinks(manifest, file, root) {
 	return { chunk, file };
 }
 
+/** @type {WeakMap<import('vite').Manifest, Map<string, string>>} */
+const source_maps = new WeakMap();
+
 /**
  * @param {string[]} assets
- * @returns {string[]}
+ * @param {import('vite').Manifest} manifest
+ * @param {string} root
+ * @returns {import('types').FontDependency[]}
  */
-export function filter_fonts(assets) {
-	return assets.filter((asset) => /\.(woff2?|ttf|otf)$/.test(asset));
+export function filter_fonts(assets, manifest, root) {
+	let sources = source_maps.get(manifest);
+
+	if (!sources) {
+		sources = new Map();
+		source_maps.set(manifest, sources);
+
+		// identical files are emitted once but can have several sources — keep the first
+		for (const key of Object.keys(manifest).sort()) {
+			const { file, src } = manifest[key];
+			if (src && !sources.has(file)) {
+				sources.set(file, src);
+			}
+		}
+	}
+
+	return assets
+		.filter((asset) => /\.(woff2?|ttf|otf)$/.test(asset))
+		.map((file) => {
+			const src = sources.get(file) ?? file;
+			const marker = '/node_modules/';
+			const index = src.lastIndexOf(marker);
+
+			// Vite follows package manager symlinks when generating the manifest. Prefer the
+			// project-local node_modules path when it points to the same file.
+			if (index !== -1) {
+				const filename = `node_modules/${src.slice(index + marker.length)}`;
+				const source = path.resolve(root, src);
+				const unresolved = path.resolve(root, filename);
+
+				if (
+					fs.existsSync(source) &&
+					fs.existsSync(unresolved) &&
+					fs.realpathSync(unresolved) === fs.realpathSync(source)
+				) {
+					return { file, filename };
+				}
+			}
+
+			return { file, filename: normalizePath(path.relative(root, path.resolve(root, src))) };
+		});
 }
 
 /**

package/src/exports/vite/dev/index.js

@@ -25,6 +25,9 @@ import { SCHEME } from '../../../utils/url.js';
 import { check_feature } from '../../../utils/features.js';
 import { escape_html } from '../../../utils/escape.js';
 import { get_runner } from '../../../runner.js';
+import { write_server } from '../../../core/sync/write_server.js';
+import { write_tsconfig } from '../../../core/sync/write_tsconfig/index.js';
+import create_manifest_data from '../../../core/sync/create_manifest_data/index.js';
 
 // vite-specifc queries that we should skip handling for css urls
 const vite_css_query_regex = /(?:\?|&)(?:raw|url|inline)(?:&|$)/;
@@ -74,7 +77,7 @@ export async function dev(
 		return fetch(info, init);
 	};
 
-	sync.init(svelte_config, root);
+	write_tsconfig(svelte_config, root);
 
 	/** @type {ManifestData} */
 	let manifest_data;
@@ -86,6 +89,20 @@ export async function dev(
 
 	const runner = get_runner(vite, vite_dev_server);
 
+	/**
+	 * Log a response to the console, routed through Vite's logger so that it
+	 * respects the configured `logLevel` and any `customLogger`
+	 * @param {number} status
+	 * @param {string} log
+	 */
+	function log_dev_response(status, log) {
+		if (status < 400) {
+			vite_dev_server.config.logger.info(log);
+		} else {
+			vite_dev_server.config.logger.error(log);
+		}
+	}
+
 	/**
 	 * @param {string} url
 	 * @returns {Promise<Record<string, any>>}
@@ -135,7 +152,8 @@ export async function dev(
 
 	async function update_manifest() {
 		try {
-			({ manifest_data } = sync.create(svelte_config, root));
+			manifest_data = create_manifest_data(svelte_config, root);
+			sync.create(svelte_config, root, manifest_data, false);
 			set_manifest_data(manifest_data);
 
 			await load_and_validate_params({
@@ -172,7 +190,7 @@ export async function dev(
 			_: {
 				client: {
 					start: `${get_runtime_base(root)}/client/entry.js`,
-					app: `${to_fs(svelte_config.outDir)}/generated/client/app.js`,
+					app: `${to_fs(svelte_config.outDir)}/generated/dev/client/app.js`,
 					imports: [],
 					stylesheets: [],
 					fonts: [],
@@ -182,7 +200,7 @@ export async function dev(
 							? undefined
 							: manifest_data.nodes.map((node, i) => {
 									if (node.component || node.universal) {
-										return `${svelte_config.paths.base}${to_fs(svelte_config.outDir)}/generated/client/nodes/${i}.js`;
+										return `${svelte_config.paths.base}${to_fs(svelte_config.outDir)}/generated/dev/client/nodes/${i}.js`;
 									}
 								}),
 					// `css` is not necessary in dev, as the JS file from `nodes` will reference the CSS file
@@ -450,7 +468,7 @@ export async function dev(
 			file.startsWith(serviceWorker) ||
 			file.startsWith(hooks.server)
 		) {
-			sync.server(svelte_config, root);
+			write_server(svelte_config, path.join(svelte_config.outDir, 'generated', 'dev'), root);
 		}
 	});
 
@@ -576,7 +594,7 @@ export async function dev(
 					await runner.import(`${get_runtime_base(root)}/server/index.js`)
 				);
 
-				const { set_fix_stack_trace, log_response } = await runner.import(
+				const { set_fix_stack_trace, format_response } = await runner.import(
 					`${get_runtime_base(root)}/server/internal.js`
 				);
 				set_fix_stack_trace(fix_stack_trace);
@@ -593,7 +611,8 @@ export async function dev(
 
 				const request = getRequest({
 					base,
-					request: req
+					request: req,
+					response: res
 				});
 
 				if (manifest_error) {
@@ -642,11 +661,11 @@ export async function dev(
 				if (rendered.status === 404) {
 					// @ts-expect-error
 					serve_static_middleware.handle(req, res, () => {
-						log_response(rendered.status, request);
+						log_dev_response(rendered.status, format_response(rendered.status, request));
 						setResponse(res, rendered);
 					});
 				} else {
-					log_response(rendered.status, request);
+					log_dev_response(rendered.status, format_response(rendered.status, request));
 					setResponse(res, rendered);
 				}
 			} catch (e) {
@@ -736,19 +755,3 @@ function has_correct_case(file, assets) {
 
 	return false;
 }
-
-/**
- * Invalidates a module in all environments.
- * @param {ViteDevServer} server
- * @param {string} id
- * @returns {void}
- */
-export function invalidate_module(server, id) {
-	for (const environment in server.environments) {
-		const module = server.environments[environment].moduleGraph.getModuleById(id);
-		if (module) {
-			server.environments[environment].moduleGraph.invalidateModule(module);
-			void server.environments[environment].reloadModule(module);
-		}
-	}
-}