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

package/src/runtime/server/utils.js

@@ -29,13 +29,6 @@ export function allowed_methods(mod) {
 	return allowed;
 }
 
-/**
- * @param {import('types').SSROptions} options
- */
-export function get_global_name(options) {
-	return __SVELTEKIT_DEV__ ? '__sveltekit_dev' : `__sveltekit_${options.version_hash}`;
-}
-
 /**
  * @param {number} status
  * @param {string} location

package/src/runtime/utils.js

@@ -1,6 +1,47 @@
 import { BROWSER } from 'esm-env';
 
 export const text_encoder = new TextEncoder();
+
+/**
+ * `ReadableStream.from`, for runtimes that don't support it (as of writing, every Bun release)
+ * @template T
+ * @param {AsyncIterable<T>} iterable
+ * @returns {ReadableStream<T>}
+ */
+export function stream_from_iterable(iterable) {
+	// TODO remove the casts once TypeScript's lib includes `ReadableStream.from`
+	if (/** @type {any} */ (ReadableStream).from) {
+		return /** @type {any} */ (ReadableStream).from(iterable);
+	}
+
+	const iterator = iterable[Symbol.asyncIterator]();
+	return new ReadableStream({
+		async pull(controller) {
+			const { value, done } = await iterator.next();
+			if (done) controller.close();
+			else controller.enqueue(value);
+		},
+		async cancel(reason) {
+			await iterator.return?.(reason);
+		}
+	});
+}
+
+/**
+ * @param {string} head
+ * @param {AsyncIterable<string>} chunks
+ * @returns {ReadableStream<Uint8Array>} `head` followed by each non-empty chunk, encoded
+ */
+export function stream_text(head, chunks) {
+	return stream_from_iterable(
+		(async function* () {
+			yield text_encoder.encode(head);
+			for await (const chunk of chunks) {
+				if (chunk) yield text_encoder.encode(chunk);
+			}
+		})()
+	);
+}
 export const text_decoder = new TextDecoder();
 
 /**

package/src/telemetry.js

@@ -1,36 +1,4 @@
-/** @import { Tracer, Span, SpanContext } from '@opentelemetry/api' */
-
-/**
- * Tracer implementation that does nothing (null object).
- * @type {Tracer}
- */
-export const noop_tracer = {
-	/**
-	 * @returns {Span}
-	 */
-	startSpan() {
-		return noop_span;
-	},
-
-	/**
-	 * @param {unknown} _name
-	 * @param {unknown} arg_1
-	 * @param {unknown} [arg_2]
-	 * @param {Function} [arg_3]
-	 * @returns {unknown}
-	 */
-	startActiveSpan(_name, arg_1, arg_2, arg_3) {
-		if (typeof arg_1 === 'function') {
-			return arg_1(noop_span);
-		}
-		if (typeof arg_2 === 'function') {
-			return arg_2(noop_span);
-		}
-		if (typeof arg_3 === 'function') {
-			return arg_3(noop_span);
-		}
-	}
-};
+/** @import { Span, SpanContext } from '@opentelemetry/api' */
 
 /**
  * @type {Span}

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

@@ -1,18 +1,10 @@
-/** Internal version of $app/paths */
-declare module '__sveltekit/paths' {
-	export let base: '' | `/${string}`;
-	export let assets: '' | `https://${string}` | `http://${string}` | '/_svelte_kit_assets';
-	export let app_dir: string;
-	export let relative: boolean;
-	export function reset(): void;
-	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' {
+declare module '<sveltekit:generated>/server.js' {
 	import { SSRManifest } from '@sveltejs/kit';
+	import { SSROptions, ServerHooks } from 'types';
 
+	export const options: SSROptions;
+	export const get_hooks: () => Promise<Partial<ServerHooks>>;
 	export let fix_stack_trace: (error: Error) => string;
 	export let manifest: SSRManifest;
 	export function read_implementation(path: string): ReadableStream;
@@ -21,7 +13,7 @@ declare module '__sveltekit/server' {
 	export function set_read_implementation(fn: (path: string) => ReadableStream): void;
 }
 
-declare module '__sveltekit/env' {
+declare module '<sveltekit:generated>/env/config.js' {
 	// exported environment variables are defined in env.d.ts
 
 	/** Populate exported environment variables */
@@ -34,20 +26,20 @@ declare module '__sveltekit/env' {
 	export const rendered_env: Record<string, any>;
 }
 
-declare module '__sveltekit/env/private' {
+declare module '<sveltekit:generated>/env/private/server.js' {
 	// exported environment variables are defined in env.d.ts
 }
 
-declare module '__sveltekit/env/public/client' {
+declare module '<sveltekit:generated>/env/public/client.js' {
 	// exported environment variables are defined in env.d.ts
 }
 
-declare module '__sveltekit/env/public/server' {
+declare module '<sveltekit:generated>/env/public/server.js' {
 	// exported environment variables are defined in env.d.ts
 }
 
 /** Internal version of $app/manifest */
-declare module '__sveltekit/manifest-data' {
+declare module '<sveltekit:generated>/app-manifest.js' {
 	export const immutable: Array<{ path: string }>;
 	export const assets: Array<{ path: string }>;
 	export const prerendered: Array<{ path: string }>;

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

@@ -13,7 +13,15 @@ declare global {
 	 * it is influenced by `NODE_ENV` which can still be true during `vite preview`
 	 */
 	const __SVELTEKIT_DEV__: boolean;
+	const __SVELTEKIT_CSRF_CHECK_ORIGIN__: boolean;
 	const __SVELTEKIT_EMBEDDED__: boolean;
+	/** True if `config.output.linkHeaderPreload` is `true` */
+	const __SVELTEKIT_LINK_HEADER_PRELOAD__: boolean;
+	const __SVELTEKIT_PATHS_ORIGIN__: string | undefined;
+	/** True if the app has a service worker and `config.serviceWorker.register` is `true` */
+	const __SVELTEKIT_SERVICE_WORKER__: boolean;
+	/** The `__sveltekit_xxx` name the payload object is attached to, without `globalThis.` */
+	const __SVELTEKIT_GLOBAL_NAME__: string;
 	const __SVELTEKIT_PATHS_ASSETS__: string;
 	const __SVELTEKIT_PATHS_BASE__: string;
 	const __SVELTEKIT_PATHS_RELATIVE__: boolean;

package/src/types/internal.d.ts

@@ -8,7 +8,8 @@ import {
 	Actions,
 	RequestEvent,
 	SSRManifest,
-	Emulator
+	Emulator,
+	HttpError
 } from '@sveltejs/kit';
 import { RemoteFormIssue, RemoteQuery, RemoteLiveQuery } from '$app/server';
 import { Config } from '@sveltejs/kit/vite';
@@ -47,7 +48,7 @@ export interface ServerInternalModule {
 	set_version(version: string): void;
 	set_fix_stack_trace(fix_stack_trace: (error: Error) => void): void;
 	get_hooks: () => Promise<Record<string, any>>;
-	log_response: (status: number, request: Request) => void;
+	format_response: (status: number, request: Request) => string;
 }
 
 export interface Asset {
@@ -61,10 +62,17 @@ export interface AssetDependencies {
 	file: string;
 	imports: string[];
 	stylesheets: string[];
-	fonts: string[];
+	fonts: FontDependency[];
 	stylesheet_map: Map<string, { css: Set<string>; assets: Set<string> }>;
 }
 
+export interface FontDependency {
+	/** emitted file path, relative to the client output directory */
+	file: string;
+	/** the source file path relative to the project root, before hashing and character sanitization */
+	filename: string;
+}
+
 export interface BuildData {
 	app_dir: string;
 	app_path: string;
@@ -97,7 +105,7 @@ export interface BuildData {
 		 */
 		routes?: SSRClientRoute[];
 		stylesheets: string[];
-		fonts: string[];
+		fonts: FontDependency[];
 		/**
 		 * Whether the client uses public dynamic env vars — `$env/dynamic/public` or `$app/env/public`.
 		 */
@@ -292,6 +300,14 @@ export interface RouteData {
 	} | null;
 }
 
+/**
+ * The server-side form of `ActionResult`, before the error is passed
+ * through `handleError` and the data is serialized
+ */
+export type ServerActionResult =
+	| Exclude<import('$app/forms').ActionResult, { type: 'error' }>
+	| { type: 'error'; location: string; error: Error | HttpError };
+
 export type ServerRedirectNode = {
 	type: 'redirect';
 	status: number;
@@ -449,7 +465,7 @@ export interface SSRNode {
 	/** external CSS files that are loaded on the client */
 	stylesheets: string[];
 	/** external font files that are loaded on the client */
-	fonts: string[];
+	fonts: FontDependency[];
 
 	universal_id?: string;
 	server_id?: string;
@@ -477,14 +493,7 @@ export type SSRNodeLoader = () => Promise<SSRNode>;
 export interface SSROptions {
 	app_template_contains_nonce: boolean;
 	csp: ValidatedConfig['csp'];
-	csrf_check_origin: boolean;
 	csrf_trusted_origins: string[];
-	embedded: boolean;
-	hash_routing: boolean;
-	hooks: ServerHooks;
-	link_header_preload: ValidatedConfig['output']['linkHeaderPreload'];
-	paths_origin: string | undefined;
-	service_worker: boolean;
 	service_worker_options: RegistrationOptions;
 	templates: {
 		app(values: {
@@ -496,8 +505,6 @@ export interface SSROptions {
 		}): string;
 		error(values: { message: string; status: number }): string;
 	};
-	version: string;
-	version_hash: string;
 }
 
 export interface PageNodeIndexes {
@@ -590,7 +597,7 @@ export interface RemoteQueryLiveInternals extends BaseRemoteInternals {
 export interface RemoteQueryBatchInternals extends BaseRemoteInternals {
 	type: 'query_batch';
 	validate: (arg?: any) => MaybePromise<any>;
-	run: (args: any[], options: SSROptions) => Promise<any[]>;
+	run: (args: any[]) => Promise<any[]>;
 	/**
 	 * Creates a `RemoteQuery` bound directly to a specific client payload (the
 	 * stringified raw argument) and a pre-validated argument, skipping the query
@@ -675,6 +682,11 @@ export interface RequestState {
 	 * True if we're currently attempting to render an error page.
 	 */
 	error: boolean;
+	/**
+	 * The rerouted URL (only if the new pathname differs from the original).
+	 * Used by platforms that serve a catch-all serverless function.
+	 */
+	rerouted_url: string | null;
 	/**
 	 * Allows us to prevent `event.fetch` from making infinitely looping internal requests.
 	 */

package/src/types/private.d.ts

@@ -154,7 +154,7 @@ export interface CspDirectives {
 	>;
 }
 
-export type HttpMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS';
+export type HttpMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'QUERY';
 
 export interface Logger {
 	(msg: string): void;

package/src/utils/exports.js

@@ -79,6 +79,7 @@ const valid_server_exports = new Set([
 	'DELETE',
 	'OPTIONS',
 	'HEAD',
+	'QUERY',
 	'fallback',
 	'prerender',
 	'trailingSlash',

package/src/utils/filesystem.js

@@ -63,30 +63,18 @@ export function copy(source, target, opts = {}) {
 /**
  * Get a list of all files in a directory
  * @param {string} cwd - the directory to walk
- * @param {boolean} [dirs] - whether to include directories in the result
- * @returns {string[]} a list of all found files (and possibly directories) relative to `cwd`
+ * @param {string} [dir] - the subdirectory to walk, relative to `cwd`
+ * @returns {Generator<string>} the posix paths of all found files, relative to `cwd`
  */
-export function walk(cwd, dirs = false) {
-	/** @type {string[]} */
-	const all_files = [];
-
-	/** @param {string} dir */
-	function walk_dir(dir) {
-		const files = fs.readdirSync(path.join(cwd, dir));
-
-		for (const file of files) {
-			const joined = path.join(dir, file);
-			const stats = fs.statSync(path.join(cwd, joined));
-			if (stats.isDirectory()) {
-				if (dirs) all_files.push(joined);
-				walk_dir(joined);
-			} else {
-				all_files.push(joined);
-			}
+export function* walk(cwd, dir = '') {
+	for (const file of fs.readdirSync(path.join(cwd, dir))) {
+		const joined = dir ? `${dir}/${file}` : file;
+		if (fs.statSync(path.join(cwd, joined)).isDirectory()) {
+			yield* walk(cwd, joined);
+		} else {
+			yield joined;
 		}
 	}
-
-	return (walk_dir(''), all_files);
 }
 
 /**
@@ -115,7 +103,7 @@ export function relative_path(from, to) {
 /**
  * Given an entry point like [cwd]/src/hooks, returns a filename like [cwd]/src/hooks.js or [cwd]/src/hooks/index.js
  * @param {string} entry
- * @returns {string|null}
+ * @returns {string | null}
  */
 export function resolve_entry(entry) {
 	if (fs.existsSync(entry)) {

package/src/utils/functions.js

@@ -16,3 +16,13 @@ export function once(fn) {
 		return (result = fn());
 	};
 }
+
+/**
+ * @param {string} name
+ * @param {string} [parens]
+ */
+export function disallow_on_server(name, parens = '(...)') {
+	return () => {
+		throw new Error(`Cannot call \`${name}${parens}\` on the server`);
+	};
+}

package/src/utils/routing.js

@@ -116,17 +116,6 @@ export function parse_route_id(id) {
 	return { pattern, params };
 }
 
-const optional_param_regex = /\/\[\[[\w-]+?(?:=[\w-]+)?\]\]/;
-
-/**
- * Removes optional params from a route ID.
- * @param {string} id
- * @returns The route id with optional params removed
- */
-export function remove_optional_params(id) {
-	return id.replace(optional_param_regex, '');
-}
-
 /**
  * Returns `false` for `(group)` segments
  * @param {string} segment

package/src/utils/streaming.js

@@ -10,26 +10,16 @@ import { noop } from './functions.js';
  */
 export function create_async_iterator() {
 	let resolved = -1;
-	let returned = -1;
 
 	/** @type {PromiseWithResolvers<T>[]} */
 	const deferred = [];
 
 	return {
-		iterate: (transform = (x) => x) => {
-			return {
-				[Symbol.asyncIterator]() {
-					return {
-						next: async () => {
-							const next = deferred[++returned];
-							if (!next) return { value: null, done: true };
-
-							const value = await next.promise;
-							return { value: transform(value), done: false };
-						}
-					};
-				}
-			};
+		async *iterate(transform = (x) => x) {
+			// `deferred` can grow while we iterate, as resolved values may add further promises
+			for (let i = 0; i < deferred.length; i += 1) {
+				yield transform(await deferred[i].promise);
+			}
 		},
 		add: (promise) => {
 			const next = Promise.withResolvers();

package/src/utils/url.js

@@ -82,17 +82,6 @@ export function decode_pathname(pathname) {
 	return pathname.split('%25').map(decodeURI).join('%25');
 }
 
-/** @param {Record<string, string>} params */
-export function decode_params(params) {
-	for (const key in params) {
-		// input has already been decoded by decodeURI
-		// now handle the rest
-		params[key] = decodeURIComponent(params[key]);
-	}
-
-	return params;
-}
-
 /**
  * The error when a URL is malformed is not very helpful, so we augment it with the URI
  * @param {string} uri

package/src/version.js

@@ -1,4 +1,4 @@
 // generated during release, do not modify
 
 /** @type {string} */
-export const VERSION = '3.0.0-next.23';
+export const VERSION = '3.0.0-next.25';

package/types/index.d.ts

@@ -150,7 +150,7 @@ declare module '@sveltejs/kit' {
 
 		/**
 		 * Generate a server-side manifest to initialise the SvelteKit [server](https://svelte.dev/docs/kit/@sveltejs-kit#Server) with.
-		 * @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;
 
@@ -828,7 +828,7 @@ declare module '@sveltejs/kit' {
 		complete(entry: { generateManifest(opts: { relativePath: string }): string }): MaybePromise<void>;
 	}
 
-	type HttpMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS';
+	type HttpMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'QUERY';
 
 	interface Logger {
 		(msg: string): void;
@@ -1065,6 +1065,25 @@ declare module '@sveltejs/kit' {
 	export {};
 }
 
+declare module '@sveltejs/kit/adapter' {
+	/**
+	 * Helps a catch-all request handler pass the request to a different handler if
+	 * the `reroute` hook has returned a URL pathname that's different from the
+	 * incoming request.
+	 *
+	 * If your adapter is capable of deploying multiple serverless functions, it's a
+	 * good idea to also deploy a "catch-all" one to handle uncaught requests.
+	 * Running this in that function allows the app's `reroute` hook to rewrite
+	 * the request URL and invoke the next appropriate serverless function, if any.
+	 * @param response The response returned from the SvelteKit `server.respond` function
+	 * @param next Your platform-specific implementation for invoking the next handler with a different request URL
+	 * @since 3.0.0
+	 */
+	export function applyReroute(response: Response, next: (url: URL) => Response | Promise<Response>): Response | Promise<Response>;
+
+	export {};
+}
+
 declare module '@sveltejs/kit/env' {
 	import type { StandardSchemaV1 } from '@standard-schema/spec';
 	/**
@@ -1317,9 +1336,17 @@ declare module '@sveltejs/kit/hooks' {
 		 * `<head>` tag; if `output.linkHeaderPreload` is enabled, dynamically rendered pages use the
 		 * [`Link` response header](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Link) instead.
 		 * By default, `js` and `css` files will be preloaded.
+		 *
+		 * For `font` files, `input` also has a `filename` property, the source file's pathname relative
+		 * to the project root, so that a filter can match on it instead of the hashed path. `js` and
+		 * `css` files are bundled and have no single source file name.
 		 * @param input the type of the file and its path
 		 */
-		preload?: (input: { type: 'font' | 'css' | 'js' | 'asset'; path: string }) => boolean;
+		preload?: (
+			input:
+				| { type: 'css' | 'js' | 'asset'; path: string }
+				| { type: 'font'; path: string; filename: string }
+		) => boolean;
 	}
 
 	type AppErrorWithOptionalDefaults = Omit<App.Error, 'status' | 'message'> & {
@@ -1418,8 +1445,9 @@ declare module '@sveltejs/kit/hooks' {
 }
 
 declare module '@sveltejs/kit/node' {
-	export function getRequest({ request, base, bodySizeLimit }: {
+	export function getRequest({ request, response, base, bodySizeLimit }: {
 		request: import("http").IncomingMessage;
+		response?: import("http").ServerResponse;
 		base: string;
 		bodySizeLimit?: number;
 	}): Request;
@@ -2288,19 +2316,16 @@ declare module '@sveltejs/kit/vite' {
 declare module '$app/env' {
 	/**
 	 * `true` if the app is running in the browser.
-	 */
+	 * */
 	export const browser: boolean;
-
 	/**
 	 * Whether the dev server is running. This is not guaranteed to correspond to `NODE_ENV` or `MODE`.
-	 */
+	 * */
 	export const dev: boolean;
-
 	/**
 	 * SvelteKit analyses your app during the `build` step by running it. During this process, `building` is `true`. This also applies during prerendering.
-	 */
+	 * */
 	export const building: boolean;
-
 	/**
 	 * The value of `config.version.name`.
 	 */
@@ -2310,25 +2335,6 @@ declare module '$app/env' {
 }
 
 declare module '$app/forms' {
-	/**
-	 * Use this function to deserialize the response from a form submission.
-	 * Usage:
-	 *
-	 * ```js
-	 * import { deserialize } from '$app/forms';
-	 *
-	 * async function handleSubmit(event) {
-	 *   const response = await fetch('/form?/action', {
-	 *     method: 'POST',
-	 *     body: new FormData(event.target)
-	 *   });
-	 *
-	 *   const result = deserialize(await response.text());
-	 *   // ...
-	 * }
-	 * ```
-	 * */
-	export function deserialize<Success extends Record<string, unknown> | undefined, Failure extends Record<string, unknown> | undefined>(result: string): ActionResult<Success, Failure>;
 	/**
 	 * This action enhances a `<form>` element that otherwise would work without JavaScript.
 	 *
@@ -2416,6 +2422,25 @@ declare module '$app/forms' {
 	 * the redirect location.
 	 * */
 	export function applyAction<Success extends Record<string, unknown> | undefined, Failure extends Record<string, unknown> | undefined>(result: ActionResult<Success, Failure>): Promise<void>;
+	/**
+	 * Use this function to deserialize the response from a form submission.
+	 * Usage:
+	 *
+	 * ```js
+	 * import { deserialize } from '$app/forms';
+	 *
+	 * async function handleSubmit(event) {
+	 *   const response = await fetch('/form?/action', {
+	 *     method: 'POST',
+	 *     body: new FormData(event.target)
+	 *   });
+	 *
+	 *   const result = deserialize(await response.text());
+	 *   // ...
+	 * }
+	 * ```
+	 * */
+	export function deserialize<Success extends Record<string, unknown> | undefined, Failure extends Record<string, unknown> | undefined>(result: string): ActionResult<Success, Failure>;
 	type MaybePromise<T> = T | Promise<T>;
 
 	export {};