@sveltejs/kit 1.0.0-next.42 → 1.0.0-next.422

package/src/core/utils.js

@@ -0,0 +1,58 @@
+import path from 'path';
+import colors from 'kleur';
+import { fileURLToPath } from 'url';
+import { posixify } from '../utils/filesystem.js';
+
+/**
+ * Resolved path of the `runtime` directory
+ *
+ * TODO Windows issue:
+ * Vite or sth else somehow sets the driver letter inconsistently to lower or upper case depending on the run environment.
+ * In playwright debug mode run through VS Code this a root-to-lowercase conversion is needed in order for the tests to run.
+ * If we do this conversion in other cases it has the opposite effect though and fails.
+ */
+export const runtime_directory = posixify(fileURLToPath(new URL('../runtime', import.meta.url)));
+
+/** Prefix for the `runtime` directory, for use with import declarations */
+export const runtime_prefix = posixify_path(runtime_directory);
+
+/** @param {string} str */
+function posixify_path(str) {
+	const parsed = path.parse(str);
+	return `/${parsed.dir.slice(parsed.root.length).split(path.sep).join('/')}/${parsed.base}`;
+}
+
+function noop() {}
+
+/** @param {{ verbose: boolean }} opts */
+export function logger({ verbose }) {
+	/** @type {import('types').Logger} */
+	const log = (msg) => console.log(msg.replace(/^/gm, '  '));
+
+	/** @param {string} msg */
+	const err = (msg) => console.error(msg.replace(/^/gm, '  '));
+
+	log.success = (msg) => log(colors.green(`✔ ${msg}`));
+	log.error = (msg) => err(colors.bold().red(msg));
+	log.warn = (msg) => log(colors.bold().yellow(msg));
+
+	log.minor = verbose ? (msg) => log(colors.grey(msg)) : noop;
+	log.info = verbose ? log : noop;
+
+	return log;
+}
+
+/** @param {import('types').ManifestData} manifest_data */
+export function get_mime_lookup(manifest_data) {
+	/** @type {Record<string, string>} */
+	const mime = {};
+
+	manifest_data.assets.forEach((asset) => {
+		if (asset.type) {
+			const ext = path.extname(asset.file);
+			mime[ext] = asset.type;
+		}
+	});
+
+	return mime;
+}

package/src/hooks.js

@@ -0,0 +1,26 @@
+/**
+ * @param {...import('types').Handle} handlers
+ * @returns {import('types').Handle}
+ */
+export function sequence(...handlers) {
+	const length = handlers.length;
+	if (!length) return ({ event, resolve }) => resolve(event);
+
+	return ({ event, resolve }) => {
+		return apply_handle(0, event);
+
+		/**
+		 * @param {number} i
+		 * @param {import('types').RequestEvent} event
+		 * @returns {import('types').MaybePromise<Response>}
+		 */
+		function apply_handle(i, event) {
+			const handle = handlers[i];
+
+			return handle({
+				event,
+				resolve: i < length - 1 ? (event) => apply_handle(i + 1, event) : resolve
+			});
+		}
+	};
+}

package/src/index/index.js

@@ -0,0 +1,45 @@
+import { HttpError, Redirect } from './private.js';
+
+/**
+ * Creates an `HttpError` object with an HTTP status code and an optional message.
+ * This object, if thrown during request handling, will cause SvelteKit to
+ * return an error response without invoking `handleError`
+ * @param {number} status
+ * @param {string | undefined} [message]
+ */
+export function error(status, message) {
+	return new HttpError(status, message);
+}
+
+/**
+ * Creates a `Redirect` object. If thrown during request handling, SvelteKit will
+ * return a redirect response.
+ * @param {number} status
+ * @param {string} location
+ */
+export function redirect(status, location) {
+	if (isNaN(status) || status < 300 || status > 399) {
+		throw new Error('Invalid status code');
+	}
+
+	return new Redirect(status, location);
+}
+
+/**
+ * Generates a JSON `Response` object from the supplied data.
+ * @param {any} data
+ * @param {ResponseInit} [init]
+ */
+export function json(data, init) {
+	// TODO deprecate this in favour of `Response.json` when it's
+	// more widely supported
+	const headers = new Headers(init?.headers);
+	if (!headers.has('content-type')) {
+		headers.set('content-type', 'application/json');
+	}
+
+	return new Response(JSON.stringify(data), {
+		...init,
+		headers
+	});
+}

package/src/index/private.js

@@ -0,0 +1,33 @@
+export class HttpError {
+	// without these, things like `$page.error.stack` will error. we don't want to
+	// include a stack for these sorts of errors, but we also don't want red
+	// squigglies everywhere, so this feels like a not-terribile compromise
+	name = 'HttpError';
+
+	/** @type {void} */
+	stack = undefined;
+
+	/**
+	 * @param {number} status
+	 * @param {string | undefined} message
+	 */
+	constructor(status, message) {
+		this.status = status;
+		this.message = message ?? `Error: ${status}`;
+	}
+
+	toString() {
+		return this.message;
+	}
+}
+
+export class Redirect {
+	/**
+	 * @param {number} status
+	 * @param {string} location
+	 */
+	constructor(status, location) {
+		this.status = status;
+		this.location = location;
+	}
+}

package/src/node/index.js

@@ -0,0 +1,145 @@
+import * as set_cookie_parser from 'set-cookie-parser';
+
+/** @param {import('http').IncomingMessage} req */
+function get_raw_body(req) {
+	const h = req.headers;
+
+	if (!h['content-type']) {
+		return null;
+	}
+
+	const length = Number(h['content-length']);
+
+	// check if no request body
+	// https://github.com/jshttp/type-is/blob/c1f4388c71c8a01f79934e68f630ca4a15fffcd6/index.js#L81-L95
+	if (isNaN(length) && h['transfer-encoding'] == null) {
+		return null;
+	}
+
+	if (req.destroyed) {
+		const readable = new ReadableStream();
+		readable.cancel();
+		return readable;
+	}
+
+	let size = 0;
+	let cancelled = false;
+
+	return new ReadableStream({
+		start(controller) {
+			req.on('error', (error) => {
+				controller.error(error);
+			});
+
+			req.on('end', () => {
+				if (cancelled) return;
+				controller.close();
+			});
+
+			req.on('data', (chunk) => {
+				if (cancelled) return;
+
+				size += chunk.length;
+				if (size > length) {
+					controller.error(new Error('content-length exceeded'));
+					return;
+				}
+
+				controller.enqueue(chunk);
+
+				if (controller.desiredSize === null || controller.desiredSize <= 0) {
+					req.pause();
+				}
+			});
+		},
+
+		pull() {
+			req.resume();
+		},
+
+		cancel(reason) {
+			cancelled = true;
+			req.destroy(reason);
+		}
+	});
+}
+
+/** @type {import('@sveltejs/kit/node').getRequest} */
+export async function getRequest(base, req) {
+	let headers = /** @type {Record<string, string>} */ (req.headers);
+	if (req.httpVersionMajor === 2) {
+		// we need to strip out the HTTP/2 pseudo-headers because node-fetch's
+		// Request implementation doesn't like them
+		// TODO is this still true with Node 18
+		headers = Object.assign({}, headers);
+		delete headers[':method'];
+		delete headers[':path'];
+		delete headers[':authority'];
+		delete headers[':scheme'];
+	}
+
+	return new Request(base + req.url, {
+		method: req.method,
+		headers,
+		body: get_raw_body(req)
+	});
+}
+
+/** @type {import('@sveltejs/kit/node').setResponse} */
+export async function setResponse(res, response) {
+	const headers = Object.fromEntries(response.headers);
+
+	if (response.headers.has('set-cookie')) {
+		const header = /** @type {string} */ (response.headers.get('set-cookie'));
+		const split = set_cookie_parser.splitCookiesString(header);
+
+		// @ts-expect-error
+		headers['set-cookie'] = split;
+	}
+
+	res.writeHead(response.status, headers);
+
+	if (!response.body) {
+		res.end();
+		return;
+	}
+
+	const reader = response.body.getReader();
+
+	if (res.destroyed) {
+		reader.cancel();
+		return;
+	}
+
+	const cancel = (/** @type {Error|undefined} */ error) => {
+		res.off('close', cancel);
+		res.off('error', cancel);
+
+		// If the reader has already been interrupted with an error earlier,
+		// then it will appear here, it is useless, but it needs to be catch.
+		reader.cancel(error).catch(() => {});
+		if (error) res.destroy(error);
+	};
+
+	res.on('close', cancel);
+	res.on('error', cancel);
+
+	next();
+	async function next() {
+		try {
+			for (;;) {
+				const { done, value } = await reader.read();
+
+				if (done) break;
+
+				if (!res.write(value)) {
+					res.once('drain', next);
+					return;
+				}
+			}
+			res.end();
+		} catch (error) {
+			cancel(error instanceof Error ? error : new Error(String(error)));
+		}
+	}
+}

package/src/node/polyfills.js

@@ -0,0 +1,40 @@
+import { fetch, Response, Request, Headers } from 'undici';
+import { ReadableStream, TransformStream, WritableStream } from 'stream/web';
+import { Readable } from 'stream';
+import { Request as NodeFetchRequest } from 'node-fetch';
+import { webcrypto as crypto } from 'crypto';
+
+/** @type {Record<string, any>} */
+const globals = {
+	crypto,
+	fetch,
+	Response,
+	// TODO remove the superclass as soon as Undici supports formData
+	// https://github.com/nodejs/undici/issues/974
+	Request: class extends Request {
+		// @ts-expect-error
+		formData() {
+			return new NodeFetchRequest(this.url, {
+				method: this.method,
+				headers: this.headers,
+				body: this.body && Readable.from(this.body)
+			}).formData();
+		}
+	},
+	Headers,
+	ReadableStream,
+	TransformStream,
+	WritableStream
+};
+
+// exported for dev/preview and node environments
+export function installPolyfills() {
+	for (const name in globals) {
+		Object.defineProperty(globalThis, name, {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: globals[name]
+		});
+	}
+}

package/src/runtime/app/env.js

@@ -0,0 +1,11 @@
+/**
+ * @type {import('$app/env').browser}
+ */
+export const browser = !import.meta.env.SSR;
+
+/**
+ * @type {import('$app/env').dev}
+ */
+export const dev = __SVELTEKIT_DEV__;
+
+export { prerendering } from '../env.js';

package/src/runtime/app/navigation.js

@@ -0,0 +1,22 @@
+import { client } from '../client/singletons.js';
+
+/**
+ * @param {string} name
+ */
+function guard(name) {
+	return () => {
+		throw new Error(`Cannot call ${name}(...) on the server`);
+	};
+}
+
+const ssr = import.meta.env.SSR;
+
+export const disableScrollHandling = ssr
+	? guard('disableScrollHandling')
+	: client.disable_scroll_handling;
+export const goto = ssr ? guard('goto') : client.goto;
+export const invalidate = ssr ? guard('invalidate') : client.invalidate;
+export const prefetch = ssr ? guard('prefetch') : client.prefetch;
+export const prefetchRoutes = ssr ? guard('prefetchRoutes') : client.prefetch_routes;
+export const beforeNavigate = ssr ? () => {} : client.before_navigate;
+export const afterNavigate = ssr ? () => {} : client.after_navigate;

package/src/runtime/app/paths.js

@@ -0,0 +1 @@
+export { base, assets } from '../paths.js';

package/src/runtime/app/stores.js

@@ -0,0 +1,91 @@
+import { getContext } from 'svelte';
+import { browser } from './env.js';
+
+// TODO remove this (for 1.0? after 1.0?)
+let warned = false;
+export function stores() {
+	if (!warned) {
+		console.error('stores() is deprecated; use getStores() instead');
+		warned = true;
+	}
+	return getStores();
+}
+
+/**
+ * @type {import('$app/stores').getStores}
+ */
+export const getStores = () => {
+	const stores = getContext('__svelte__');
+
+	return {
+		page: {
+			subscribe: stores.page.subscribe
+		},
+		navigating: {
+			subscribe: stores.navigating.subscribe
+		},
+		// TODO remove this (for 1.0? after 1.0?)
+		// @ts-expect-error - deprecated, not part of type definitions, but still callable
+		get preloading() {
+			console.error('stores.preloading is deprecated; use stores.navigating instead');
+			return {
+				subscribe: stores.navigating.subscribe
+			};
+		},
+		get session() {
+			removed_session();
+			return {};
+		},
+		updated: stores.updated
+	};
+};
+
+/** @type {typeof import('$app/stores').page} */
+export const page = {
+	/** @param {(value: any) => void} fn */
+	subscribe(fn) {
+		const store = getStores().page;
+		return store.subscribe(fn);
+	}
+};
+
+/** @type {typeof import('$app/stores').navigating} */
+export const navigating = {
+	subscribe(fn) {
+		const store = getStores().navigating;
+		return store.subscribe(fn);
+	}
+};
+
+function removed_session() {
+	// TODO remove for 1.0
+	throw new Error(
+		'stores.session is no longer available. See https://github.com/sveltejs/kit/discussions/5883'
+	);
+}
+
+export const session = {
+	subscribe: removed_session,
+	set: removed_session,
+	update: removed_session
+};
+
+/** @type {typeof import('$app/stores').updated} */
+export const updated = {
+	subscribe(fn) {
+		const store = getStores().updated;
+
+		if (browser) {
+			updated.check = store.check;
+		}
+
+		return store.subscribe(fn);
+	},
+	check: () => {
+		throw new Error(
+			browser
+				? `Cannot check updated store before subscribing`
+				: `Can only check updated store in browser`
+		);
+	}
+};

package/src/runtime/client/ambient.d.ts

@@ -0,0 +1,17 @@
+declare module '__GENERATED__/client-manifest.js' {
+	import { CSRPageNodeLoader, ParamMatcher } from 'types';
+
+	/**
+	 * A list of all the error/layout/page nodes used in the app
+	 */
+	export const nodes: CSRPageNodeLoader[];
+
+	/**
+	 * A map of `[routeId: string]: [errors, layouts, page]` tuples, which
+	 * is parsed into an array of routes on startup. The numbers refer to the
+	 * indices in `nodes`.
+	 */
+	export const dictionary: Record<string, [number[], number[], number]>;
+
+	export const matchers: Record<string, ParamMatcher>;
+}