@sveltejs/kit 2.3.5 → 2.4.1

package/src/exports/vite/index.js

@@ -31,7 +31,8 @@ import {
 	env_static_public,
 	service_worker,
 	sveltekit_environment,
-	sveltekit_paths
+	sveltekit_paths,
+	sveltekit_server
 } from './module_ids.js';
 import { pathToFileURL } from 'node:url';
 
@@ -224,6 +225,13 @@ async function kit({ svelte_config }) {
 	const service_worker_entry_file = resolve_entry(kit.files.serviceWorker);
 	const parsed_service_worker = path.parse(kit.files.serviceWorker);
 
+	/**
+	 * A map showing which features (such as `$app/server:read`) are defined
+	 * in which chunks, so that we can later determine which routes use which features
+	 * @type {Record<string, string[]>}
+	 */
+	const tracked_features = {};
+
 	const sourcemapIgnoreList = /** @param {string} relative_path */ (relative_path) =>
 		relative_path.includes('node_modules') || relative_path.includes(kit.outDir);
 
@@ -492,13 +500,29 @@ async function kit({ svelte_config }) {
 						}
 					`;
 				}
+
+				case sveltekit_server: {
+					return dedent`
+						export let read_implementation = null;
+
+						export let manifest = null;
+
+						export function set_read_implementation(fn) {
+							read_implementation = fn;
+						}
+
+						export function set_manifest(_) {
+							manifest = _;
+						}
+					`;
+				}
 			}
 		}
 	};
 
 	/**
 	 * Ensures that client-side code can't accidentally import server-side code,
-	 * whether in `*.server.js` files, `$lib/server`, or `$env/[static|dynamic]/private`
+	 * whether in `*.server.js` files, `$app/server`, `$lib/server`, or `$env/[static|dynamic]/private`
 	 * @type {import('vite').Plugin}
 	 */
 	const plugin_guard = {
@@ -621,7 +645,7 @@ async function kit({ svelte_config }) {
 							preserveEntrySignatures: 'strict'
 						},
 						ssrEmitAssets: true,
-						target: ssr ? 'node18.13' : 'es2022'
+						target: ssr ? 'node18.13' : undefined
 					},
 					publicDir: kit.files.assets,
 					worker: {
@@ -685,6 +709,19 @@ async function kit({ svelte_config }) {
 			}
 		},
 
+		renderChunk(code, chunk) {
+			if (code.includes('__SVELTEKIT_TRACK__')) {
+				return {
+					code: code.replace(/__SVELTEKIT_TRACK__\('(.+?)'\)/g, (_, label) => {
+						(tracked_features[chunk.name + '.js'] ??= []).push(label);
+						// put extra whitespace at the end of the comment to preserve the source size and avoid interfering with source maps
+						return `/* track ${label}            */`;
+					}),
+					map: null // TODO we may need to generate a sourcemap in future
+				};
+			}
+		},
+
 		generateBundle() {
 			if (vite_config.build.ssr) return;
 
@@ -716,6 +753,7 @@ async function kit({ svelte_config }) {
 					app_dir: kit.appDir,
 					app_path: `${kit.paths.base.slice(1)}${kit.paths.base ? '/' : ''}${kit.appDir}`,
 					manifest_data,
+					out_dir: out,
 					service_worker: service_worker_entry_file ? 'service-worker.js' : null, // TODO make file configurable?
 					client: null,
 					server_manifest
@@ -738,6 +776,9 @@ async function kit({ svelte_config }) {
 
 				const metadata = await analyse({
 					manifest_path,
+					manifest_data,
+					server_manifest,
+					tracked_features,
 					env: { ...env.private, ...env.public }
 				});
 

package/src/exports/vite/module_ids.js

@@ -1,7 +1,16 @@
+import { fileURLToPath } from 'node:url';
+
 export const env_static_private = '\0virtual:$env/static/private';
 export const env_static_public = '\0virtual:$env/static/public';
 export const env_dynamic_private = '\0virtual:$env/dynamic/private';
 export const env_dynamic_public = '\0virtual:$env/dynamic/public';
+
 export const service_worker = '\0virtual:$service-worker';
-export const sveltekit_paths = '\0virtual:__sveltekit/paths';
+
 export const sveltekit_environment = '\0virtual:__sveltekit/environment';
+export const sveltekit_paths = '\0virtual:__sveltekit/paths';
+export const sveltekit_server = '\0virtual:__sveltekit/server';
+
+export const app_server = fileURLToPath(
+	new URL('../../runtime/app/server/index.js', import.meta.url)
+);

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

@@ -4,7 +4,7 @@ import { pathToFileURL } from 'node:url';
 import { lookup } from 'mrmime';
 import sirv from 'sirv';
 import { loadEnv, normalizePath } from 'vite';
-import { getRequest, setResponse } from '../../../exports/node/index.js';
+import { createReadableStream, getRequest, setResponse } from '../../../exports/node/index.js';
 import { installPolyfills } from '../../../exports/node/polyfills.js';
 import { SVELTE_KIT_ASSETS } from '../../../constants.js';
 import { not_found } from '../utils.js';
@@ -47,7 +47,8 @@ export async function preview(vite, vite_config, svelte_config) {
 
 	const server = new Server(manifest);
 	await server.init({
-		env: loadEnv(vite_config.mode, svelte_config.kit.env.dir, '')
+		env: loadEnv(vite_config.mode, svelte_config.kit.env.dir, ''),
+		read: (file) => createReadableStream(`${dir}/${file}`)
 	});
 
 	return () => {

package/src/runtime/app/server/index.js

@@ -0,0 +1,70 @@
+import { read_implementation, manifest } from '__sveltekit/server';
+import { base } from '__sveltekit/paths';
+import { DEV } from 'esm-env';
+import { b64_decode } from '../../utils.js';
+
+/**
+ * Read the contents of an imported asset from the filesystem
+ * @example
+ * ```js
+ * import { read } from '$app/server';
+ * import somefile from './somefile.txt';
+ *
+ * const asset = read(somefile);
+ * const text = await asset.text();
+ * ```
+ * @param {string} asset
+ * @returns {Response}
+ * @since 2.4.0
+ */
+export function read(asset) {
+	__SVELTEKIT_TRACK__('$app/server:read');
+
+	if (!read_implementation) {
+		throw new Error(
+			'No `read` implementation was provided. Please ensure that your adapter is up to date and supports this feature'
+		);
+	}
+
+	// handle inline assets internally
+	if (asset.startsWith('data:')) {
+		const [prelude, data] = asset.split(';');
+		const type = prelude.slice(5) || 'application/octet-stream';
+
+		if (data.startsWith('base64,')) {
+			const decoded = b64_decode(data.slice(7));
+
+			return new Response(decoded, {
+				headers: {
+					'Content-Length': decoded.byteLength.toString(),
+					'Content-Type': type
+				}
+			});
+		}
+
+		const decoded = decodeURIComponent(data);
+
+		return new Response(decoded, {
+			headers: {
+				'Content-Length': decoded.length.toString(),
+				'Content-Type': type
+			}
+		});
+	}
+
+	const file = DEV && asset.startsWith('/@fs') ? asset : asset.slice(base.length + 1);
+
+	if (file in manifest._.server_assets) {
+		const length = manifest._.server_assets[file];
+		const type = manifest.mimeTypes[file.slice(file.lastIndexOf('.'))];
+
+		return new Response(read_implementation(file), {
+			headers: {
+				'Content-Length': '' + length,
+				'Content-Type': type
+			}
+		});
+	}
+
+	throw new Error(`Asset does not exist: ${file}`);
+}

package/src/runtime/client/client.js

@@ -1330,7 +1330,7 @@ async function navigate({
 					fn(/** @type {import('@sveltejs/kit').OnNavigate} */ (nav.navigation))
 				)
 			)
-		).filter((value) => typeof value === 'function');
+		).filter(/** @returns {value is () => void} */ (value) => typeof value === 'function');
 
 		if (after_navigate.length > 0) {
 			function cleanup() {
@@ -1341,9 +1341,7 @@ async function navigate({
 			}
 
 			after_navigate.push(cleanup);
-
-			// @ts-ignore
-			callbacks.after_navigate.push(...after_navigate);
+			after_navigate_callbacks.push(...after_navigate);
 		}
 
 		root.$set(navigation_result.props);

package/src/runtime/client/fetcher.js

@@ -1,5 +1,6 @@
 import { BROWSER, DEV } from 'esm-env';
 import { hash } from '../hash.js';
+import { b64_decode } from '../utils.js';
 
 let loading = 0;
 
@@ -77,22 +78,6 @@ if (DEV && BROWSER) {
 
 const cache = new Map();
 
-/**
- * @param {string} text
- * @returns {ArrayBufferLike}
- */
-function b64_decode(text) {
-	const d = atob(text);
-
-	const u8 = new Uint8Array(d.length);
-
-	for (let i = 0; i < d.length; i++) {
-		u8[i] = d.charCodeAt(i);
-	}
-
-	return u8.buffer;
-}
-
 /**
  * Should be called on the initial run of load functions that hydrate the page.
  * Saves any requests with cache-control max-age to the cache.

package/src/runtime/server/index.js

@@ -4,6 +4,7 @@ import { options, get_hooks } from '__SERVER__/internal.js';
 import { DEV } from 'esm-env';
 import { filter_private_env, filter_public_env } from '../../utils/env.js';
 import { prerendering } from '__sveltekit/environment';
+import { set_read_implementation, set_manifest } from '__sveltekit/server';
 
 /** @type {ProxyHandler<{ type: 'public' | 'private' }>} */
 const prerender_env_handler = {
@@ -26,14 +27,17 @@ export class Server {
 		/** @type {import('types').SSROptions} */
 		this.#options = options;
 		this.#manifest = manifest;
+
+		set_manifest(manifest);
 	}
 
 	/**
 	 * @param {{
-	 *   env: Record<string, string>
+	 *   env: Record<string, string>;
+	 *   read?: (file: string) => ReadableStream;
 	 * }} opts
 	 */
-	async init({ env }) {
+	async init({ env, read }) {
 		// Take care: Some adapters may have to call `Server.init` per-request to set env vars,
 		// so anything that shouldn't be rerun should be wrapped in an `if` block to make sure it hasn't
 		// been done already.
@@ -55,6 +59,10 @@ export class Server {
 		);
 		set_safe_public_env(public_env);
 
+		if (read) {
+			set_read_implementation(read);
+		}
+
 		if (!this.#options.hooks) {
 			try {
 				const module = await get_hooks();

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

@@ -15,6 +15,7 @@ import { render_response } from './render.js';
 import { respond_with_error } from './respond_with_error.js';
 import { get_option } from '../../../utils/options.js';
 import { get_data_json } from '../data/index.js';
+import { load_page_nodes } from './load_page_nodes.js';
 
 /**
  * The maximum request depth permitted before assuming we're stuck in an infinite loop
@@ -44,11 +45,7 @@ export async function render_page(event, page, options, manifest, state, resolve
 	}
 
 	try {
-		const nodes = await Promise.all([
-			// we use == here rather than === because [undefined] serializes as "[null]"
-			...page.layouts.map((n) => (n == undefined ? n : manifest._.nodes[n]())),
-			manifest._.nodes[page.leaf]()
-		]);
+		const nodes = await load_page_nodes(page, manifest);
 
 		const leaf_node = /** @type {import('types').SSRNode} */ (nodes.at(-1));
 

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

@@ -1,6 +1,7 @@
 import { DEV } from 'esm-env';
 import { disable_search, make_trackable } from '../../../utils/url.js';
 import { validate_depends } from '../../shared.js';
+import { b64_encode } from '../../utils.js';
 
 /**
  * Calls the user's server `load` function.
@@ -207,25 +208,6 @@ export async function load_data({
 	return result ?? null;
 }
 
-/**
- * @param {ArrayBuffer} buffer
- * @returns {string}
- */
-function b64_encode(buffer) {
-	if (globalThis.Buffer) {
-		return Buffer.from(buffer).toString('base64');
-	}
-
-	const little_endian = new Uint8Array(new Uint16Array([1]).buffer)[0] > 0;
-
-	// The Uint16Array(Uint8Array(...)) ensures the code points are padded with 0's
-	return btoa(
-		new TextDecoder(little_endian ? 'utf-16le' : 'utf-16be').decode(
-			new Uint16Array(new Uint8Array(buffer))
-		)
-	);
-}
-
 /**
  * @param {Pick<import('@sveltejs/kit').RequestEvent, 'fetch' | 'url' | 'request' | 'route'>} event
  * @param {import('types').SSRState} state

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

@@ -0,0 +1,11 @@
+/**
+ * @param {import('types').PageNodeIndexes} page
+ * @param {import('@sveltejs/kit').SSRManifest} manifest
+ */
+export function load_page_nodes(page, manifest) {
+	return Promise.all([
+		// we use == here rather than === because [undefined] serializes as "[null]"
+		...page.layouts.map((n) => (n == undefined ? n : manifest._.nodes[n]())),
+		manifest._.nodes[page.leaf]()
+	]);
+}

package/src/runtime/server/respond.js

@@ -31,6 +31,8 @@ import { json, text } from '../../exports/index.js';
 import { action_json_redirect, is_action_json_request } from './page/actions.js';
 import { INVALIDATED_PARAM, TRAILING_SLASH_PARAM } from '../shared.js';
 import { get_public_env } from './env_module.js';
+import { load_page_nodes } from './page/load_page_nodes.js';
+import { get_page_config } from '../../utils/route_config.js';
 
 /* global __SVELTEKIT_ADAPTER_NAME__ */
 
@@ -217,11 +219,7 @@ export async function respond(request, options, manifest, state) {
 			if (url.pathname === base || url.pathname === base + '/') {
 				trailing_slash = 'always';
 			} else if (route.page) {
-				const nodes = await Promise.all([
-					// we use == here rather than === because [undefined] serializes as "[null]"
-					...route.page.layouts.map((n) => (n == undefined ? n : manifest._.nodes[n]())),
-					manifest._.nodes[route.page.leaf]()
-				]);
+				const nodes = await load_page_nodes(route.page, manifest);
 
 				if (DEV) {
 					const layouts = nodes.slice(0, -1);
@@ -272,6 +270,25 @@ export async function respond(request, options, manifest, state) {
 					});
 				}
 			}
+
+			if (DEV && state.before_handle) {
+				let config = {};
+
+				/** @type {import('types').PrerenderOption} */
+				let prerender = false;
+
+				if (route.endpoint) {
+					const node = await route.endpoint();
+					config = node.config ?? config;
+					prerender = node.prerender ?? prerender;
+				} else if (route.page) {
+					const nodes = await load_page_nodes(route.page, manifest);
+					config = get_page_config(nodes);
+					prerender = get_option(nodes, 'prerender') ?? false;
+				}
+
+				state.before_handle(event, config, prerender);
+			}
 		}
 
 		const { cookies, new_cookies, get_cookie_header, set_internal } = get_cookies(

package/src/runtime/utils.js

@@ -0,0 +1,34 @@
+/**
+ * @param {string} text
+ * @returns {ArrayBufferLike}
+ */
+export function b64_decode(text) {
+	const d = atob(text);
+
+	const u8 = new Uint8Array(d.length);
+
+	for (let i = 0; i < d.length; i++) {
+		u8[i] = d.charCodeAt(i);
+	}
+
+	return u8.buffer;
+}
+
+/**
+ * @param {ArrayBuffer} buffer
+ * @returns {string}
+ */
+export function b64_encode(buffer) {
+	if (globalThis.Buffer) {
+		return Buffer.from(buffer).toString('base64');
+	}
+
+	const little_endian = new Uint8Array(new Uint16Array([1]).buffer)[0] > 0;
+
+	// The Uint16Array(Uint8Array(...)) ensures the code points are padded with 0's
+	return btoa(
+		new TextDecoder(little_endian ? 'utf-16le' : 'utf-16be').decode(
+			new Uint16Array(new Uint8Array(buffer))
+		)
+	);
+}

package/src/types/ambient-private.d.ts

@@ -16,3 +16,13 @@ declare module '__sveltekit/paths' {
 	export function override(paths: { base: string; assets: string }): void;
 	export function set_assets(path: string): void;
 }
+
+/** Internal version of $app/server */
+declare module '__sveltekit/server' {
+	import { SSRManifest } from '@sveltejs/kit';
+
+	export let manifest: SSRManifest;
+	export function read_implementation(path: string): ReadableStream;
+	export function set_manifest(manifest: SSRManifest): void;
+	export function set_read_implementation(fn: (path: string) => ReadableStream): void;
+}

package/src/types/global-private.d.ts

@@ -4,6 +4,21 @@ declare global {
 	const __SVELTEKIT_APP_VERSION_POLL_INTERVAL__: number;
 	const __SVELTEKIT_DEV__: boolean;
 	const __SVELTEKIT_EMBEDDED__: boolean;
+	/**
+	 * This makes the use of specific features visible at both dev and build time, in such a
+	 * way that we can error when they are not supported by the target platform.
+	 *
+	 * During dev, `globalThis.__SVELTEKIT_TRACK__` is a function that grabs the current `event`
+	 * and route `config` (from an AsyncLocalStorage instance) and calls the relevant `supports`
+	 * function on the adapter (e.g. `adapter.supports.read(...)`).
+	 *
+	 * At build time, if the function containing the `__SVELTEKIT_TRACK__` call is untreeshaken,
+	 * we locate it in the `renderChunk` build hook and a) make a note of the chunk that contains
+	 * it and b) replace it with a comment. Later, we can use this information to establish
+	 * which routes use which feature, and use the same `adapter.supports.read(...)` function
+	 * to throw an error if the feature would fail in production.
+	 */
+	var __SVELTEKIT_TRACK__: (label: string) => void;
 	var Bun: object;
 	var Deno: object;
 }

package/src/types/internal.d.ts

@@ -13,7 +13,9 @@ import {
 	HandleFetch,
 	Actions,
 	HandleClientError,
-	Reroute
+	Reroute,
+	RequestEvent,
+	SSRManifest
 } from '@sveltejs/kit';
 import {
 	HttpMethod,
@@ -30,9 +32,11 @@ export interface ServerModule {
 export interface ServerInternalModule {
 	set_assets(path: string): void;
 	set_building(): void;
+	set_manifest(manifest: SSRManifest): void;
 	set_prerendering(): void;
 	set_private_env(environment: Record<string, string>): void;
 	set_public_env(environment: Record<string, string>): void;
+	set_read_implementation(implementation: (path: string) => ReadableStream): void;
 	set_safe_public_env(environment: Record<string, string>): void;
 	set_version(version: string): void;
 	set_fix_stack_trace(fix_stack_trace: (error: unknown) => string): void;
@@ -45,6 +49,7 @@ export interface Asset {
 }
 
 export interface AssetDependencies {
+	assets: string[];
 	file: string;
 	imports: string[];
 	stylesheets: string[];
@@ -55,6 +60,7 @@ export interface BuildData {
 	app_dir: string;
 	app_path: string;
 	manifest_data: ManifestData;
+	out_dir: string;
 	service_worker: string | null;
 	client: {
 		start: string;
@@ -120,12 +126,19 @@ export class InternalServer extends Server {
 		options: RequestOptions & {
 			prerendering?: PrerenderOptions;
 			read: (file: string) => Buffer;
+			/** A hook called before `handle` during dev, so that `AsyncLocalStorage` can be populated */
+			before_handle?: (event: RequestEvent, config: any, prerender: PrerenderOption) => void;
 		}
 	): Promise<Response>;
 }
 
 export interface ManifestData {
 	assets: Asset[];
+	hooks: {
+		client: string | null;
+		server: string | null;
+		universal: string | null;
+	};
 	nodes: PageNode[];
 	routes: RouteData[];
 	matchers: Record<string, string>;
@@ -404,6 +417,7 @@ export interface SSRState {
 	 */
 	prerender_default?: PrerenderOption;
 	read?: (file: string) => Buffer;
+	before_handle?: (event: RequestEvent, config: any, prerender: PrerenderOption) => void;
 }
 
 export type StrictBody = string | ArrayBufferView;

package/src/utils/features.js

@@ -0,0 +1,24 @@
+/**
+ * @param {string} route_id
+ * @param {any} config
+ * @param {string} feature
+ * @param {import('@sveltejs/kit').Adapter | undefined} adapter
+ */
+export function check_feature(route_id, config, feature, adapter) {
+	if (!adapter) return;
+
+	switch (feature) {
+		case '$app/server:read': {
+			const supported = adapter.supports?.read?.({
+				route: { id: route_id },
+				config
+			});
+
+			if (!supported) {
+				throw new Error(
+					`Cannot use \`read\` from \`$app/server\` in ${route_id} when using ${adapter.name}. Please ensure that your adapter is up to date and supports this feature.`
+				);
+			}
+		}
+	}
+}

package/src/utils/route_config.js

@@ -0,0 +1,20 @@
+/**
+ * Do a shallow merge (first level) of the config object
+ * @param {Array<import('types').SSRNode | undefined>} nodes
+ */
+export function get_page_config(nodes) {
+	/** @type {any} */
+	let current = {};
+
+	for (const node of nodes) {
+		if (!node?.universal?.config && !node?.server?.config) continue;
+
+		current = {
+			...current,
+			...node?.universal?.config,
+			...node?.server?.config
+		};
+	}
+
+	return Object.keys(current).length ? current : undefined;
+}

package/src/version.js

@@ -1,4 +1,4 @@
 // generated during release, do not modify
 
 /** @type {string} */
-export const VERSION = '2.3.5';
+export const VERSION = '2.4.1';