@sveltejs/kit 1.0.0-next.41 → 1.0.0-next.410

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/packaging/index.js

@@ -0,0 +1,218 @@
+import * as fs from 'fs';
+import { dirname, join, relative } from 'path';
+import colors from 'kleur';
+import chokidar from 'chokidar';
+import { preprocess } from 'svelte/compiler';
+import { copy, mkdirp, rimraf } from '../utils/filesystem.js';
+import { analyze, generate_pkg, resolve_lib_alias, scan, strip_lang_tags, write } from './utils.js';
+import { emit_dts, transpile_ts } from './typescript.js';
+import { write_tsconfig } from '../core/sync/write_tsconfig.js';
+
+const essential_files = ['README', 'LICENSE', 'CHANGELOG', '.gitignore', '.npmignore'];
+
+/**
+ * @param {import('types').ValidatedConfig} config
+ * @param {string} cwd
+ */
+export async function build(config, cwd = process.cwd()) {
+	const { lib } = config.kit.files;
+	const { dir } = config.kit.package;
+
+	if (!fs.existsSync(lib)) {
+		throw new Error(`${lib} does not exist`);
+	}
+
+	rimraf(dir);
+	mkdirp(dir);
+
+	// Make sure generated tsconfig is up-to-date
+	write_tsconfig(config.kit, cwd);
+
+	const files = scan(config);
+
+	if (config.kit.package.emitTypes) {
+		await emit_dts(config, cwd, files);
+	}
+
+	const pkg = generate_pkg(cwd, files);
+
+	if (!pkg.svelte && files.some((file) => file.is_svelte)) {
+		// Several heuristics in Kit/vite-plugin-svelte to tell Vite to mark Svelte packages
+		// rely on the "svelte" property. Vite/Rollup/Webpack plugin can all deal with it.
+		// See https://github.com/sveltejs/kit/issues/1959 for more info and related threads.
+		if (pkg.exports['.']) {
+			const svelte_export =
+				typeof pkg.exports['.'] === 'string'
+					? pkg.exports['.']
+					: pkg.exports['.'].import || pkg.exports['.'].default;
+			if (svelte_export) {
+				pkg.svelte = svelte_export;
+			} else {
+				console.warn(
+					'Cannot generate a "svelte" entry point because the "." entry in "exports" is not a string. If you set it by hand, please also set one of the options as a "svelte" entry point\n'
+				);
+			}
+		} else {
+			console.warn(
+				'Cannot generate a "svelte" entry point because the "." entry in "exports" is missing. Please specify one or set a "svelte" entry point yourself\n'
+			);
+		}
+	}
+
+	write(join(dir, 'package.json'), JSON.stringify(pkg, null, 2));
+
+	for (const file of files) {
+		await process_file(config, file);
+	}
+
+	const whitelist = fs.readdirSync(cwd).filter((file) => {
+		const lowercased = file.toLowerCase();
+		return essential_files.some((name) => lowercased.startsWith(name.toLowerCase()));
+	});
+
+	for (const pathname of whitelist) {
+		const full_path = join(cwd, pathname);
+		if (fs.lstatSync(full_path).isDirectory()) continue; // just to be sure
+
+		const package_path = join(dir, pathname);
+		if (!fs.existsSync(package_path)) fs.copyFileSync(full_path, package_path);
+	}
+
+	const from = relative(cwd, lib);
+	const to = relative(cwd, dir);
+	console.log(colors.bold().green(`${from} -> ${to}`));
+	console.log(`Successfully built '${pkg.name}' package. To publish it to npm:`);
+	console.log(colors.bold().cyan(`  cd ${to}`));
+	console.log(colors.bold().cyan('  npm publish\n'));
+}
+
+/**
+ * @param {import('types').ValidatedConfig} config
+ */
+export async function watch(config, cwd = process.cwd()) {
+	await build(config, cwd);
+
+	const message = `\nWatching ${relative(cwd, config.kit.files.lib)} for changes...\n`;
+
+	console.log(message);
+
+	const { lib } = config.kit.files;
+	const { dir } = config.kit.package;
+
+	/** @type {Array<{ file: import('./types').File, type: string }>} */
+	const pending = [];
+
+	/** @type {Array<(value?: any) => void>} */
+	const fulfillers = [];
+
+	/** @type {NodeJS.Timeout} */
+	let timeout;
+
+	const watcher = chokidar.watch(lib, { ignoreInitial: true });
+	const ready = new Promise((resolve) => watcher.on('ready', resolve));
+
+	watcher.on('all', async (type, path) => {
+		const file = analyze(config, relative(lib, path));
+		if (!file.is_included) return;
+
+		pending.push({ file, type });
+
+		clearTimeout(timeout);
+		timeout = setTimeout(async () => {
+			const files = scan(config);
+
+			let should_update_pkg = false;
+
+			const events = pending.slice();
+			pending.length = 0;
+
+			for (const { file, type } of events) {
+				if ((type === 'unlink' || type === 'add') && file.is_exported) {
+					should_update_pkg = true;
+				}
+
+				if (type === 'unlink') {
+					for (const candidate of [
+						file.name,
+						`${file.base}.d.ts`,
+						`${file.base}.d.mts`,
+						`${file.base}.d.cts`
+					]) {
+						const resolved = join(dir, candidate);
+
+						if (fs.existsSync(resolved)) {
+							fs.unlinkSync(resolved);
+
+							const parent = dirname(resolved);
+							if (parent !== dir && fs.readdirSync(parent).length === 0) {
+								fs.rmdirSync(parent);
+							}
+						}
+					}
+					console.log(`Removed ${file.dest}`);
+				}
+
+				if (type === 'add' || type === 'change') {
+					await process_file(config, file);
+					console.log(`Processing ${file.name}`);
+				}
+			}
+
+			if (should_update_pkg) {
+				const pkg = generate_pkg(cwd, files);
+				write(join(dir, 'package.json'), JSON.stringify(pkg, null, 2));
+				console.log('Updated package.json');
+			}
+
+			if (config.kit.package.emitTypes) {
+				await emit_dts(config, cwd, scan(config));
+				console.log('Updated .d.ts files');
+			}
+
+			console.log(message);
+
+			fulfillers.forEach((fn) => fn());
+		}, 100);
+	});
+
+	return {
+		watcher,
+		ready,
+		settled: () =>
+			new Promise((fulfil, reject) => {
+				fulfillers.push(fulfil);
+				setTimeout(() => reject(new Error('Timed out')), 1000);
+			})
+	};
+}
+
+/**
+ * @param {import('types').ValidatedConfig} config
+ * @param {import('./types').File} file
+ */
+async function process_file(config, file) {
+	if (!file.is_included) return;
+
+	const filename = join(config.kit.files.lib, file.name);
+	const dest = join(config.kit.package.dir, file.dest);
+
+	if (file.is_svelte || file.name.endsWith('.ts')) {
+		let contents = fs.readFileSync(filename, 'utf-8');
+
+		if (file.is_svelte) {
+			if (config.preprocess) {
+				const preprocessed = (await preprocess(contents, config.preprocess, { filename })).code;
+				contents = strip_lang_tags(preprocessed);
+			}
+		}
+
+		if (file.name.endsWith('.ts') && !file.name.endsWith('.d.ts')) {
+			contents = await transpile_ts(filename, contents);
+		}
+
+		contents = resolve_lib_alias(file.name, contents, config);
+		write(dest, contents);
+	} else {
+		copy(filename, dest);
+	}
+}

package/src/packaging/types.d.ts

@@ -0,0 +1,8 @@
+export type File = {
+	name: string;
+	dest: string;
+	base: string;
+	is_included: boolean;
+	is_exported: boolean;
+	is_svelte: boolean;
+};