@sveltejs/kit 3.0.0-next.22 → 3.0.0-next.24

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

@@ -16,6 +16,7 @@ import { BuildData, SSRNodeLoader, SSRRoute, ValidatedConfig } from 'types';
 import { Plugin } from 'vite';
 import { RouteId as AppRouteId, LayoutParams as AppLayoutParams } from '$app/types';
 import { ParamMatcher } from '@sveltejs/kit/params';
+import { StandardSchemaV1 } from '@standard-schema/spec';
 
 export { PrerenderOption } from '../types/private.js';
 
@@ -99,6 +100,14 @@ export interface ActionFailure<T = undefined> {
 	[uniqueSymbol]: true; // necessary or else UnpackValidationError could wrongly unpack objects with the same shape as ActionFailure
 }
 
+/**
+ * A validation error thrown by `invalid`.
+ */
+export interface ValidationError {
+	/** The validation issues */
+	issues: StandardSchemaV1.Issue[];
+}
+
 type UnpackValidationError<T> =
 	T extends ActionFailure<infer X>
 		? X

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/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;
@@ -135,7 +138,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 +176,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 +186,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 +454,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);
 		}
 	});
 
@@ -593,7 +597,8 @@ export async function dev(
 
 				const request = getRequest({
 					base,
-					request: req
+					request: req,
+					response: res
 				});
 
 				if (manifest_error) {
@@ -736,19 +741,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);
-		}
-	}
-}