@sveltejs/kit 1.0.0-next.43 → 1.0.0-next.430

package/src/core/config/options.js

@@ -0,0 +1,488 @@
+import { join } from 'path';
+
+/** @typedef {import('./types').Validator} Validator */
+
+const directives = object({
+	'child-src': string_array(),
+	'default-src': string_array(),
+	'frame-src': string_array(),
+	'worker-src': string_array(),
+	'connect-src': string_array(),
+	'font-src': string_array(),
+	'img-src': string_array(),
+	'manifest-src': string_array(),
+	'media-src': string_array(),
+	'object-src': string_array(),
+	'prefetch-src': string_array(),
+	'script-src': string_array(),
+	'script-src-elem': string_array(),
+	'script-src-attr': string_array(),
+	'style-src': string_array(),
+	'style-src-elem': string_array(),
+	'style-src-attr': string_array(),
+	'base-uri': string_array(),
+	sandbox: string_array(),
+	'form-action': string_array(),
+	'frame-ancestors': string_array(),
+	'navigate-to': string_array(),
+	'report-uri': string_array(),
+	'report-to': string_array(),
+	'require-trusted-types-for': string_array(),
+	'trusted-types': string_array(),
+	'upgrade-insecure-requests': boolean(false),
+	'require-sri-for': string_array(),
+	'block-all-mixed-content': boolean(false),
+	'plugin-types': string_array(),
+	referrer: string_array()
+});
+
+/** @type {Validator} */
+const options = object(
+	{
+		extensions: validate(['.svelte'], (input, keypath) => {
+			if (!Array.isArray(input) || !input.every((page) => typeof page === 'string')) {
+				throw new Error(`${keypath} must be an array of strings`);
+			}
+
+			input.forEach((extension) => {
+				if (extension[0] !== '.') {
+					throw new Error(`Each member of ${keypath} must start with '.' — saw '${extension}'`);
+				}
+
+				if (!/^(\.[a-z0-9]+)+$/i.test(extension)) {
+					throw new Error(`File extensions must be alphanumeric — saw '${extension}'`);
+				}
+			});
+
+			return input;
+		}),
+
+		kit: object({
+			adapter: validate(null, (input, keypath) => {
+				if (typeof input !== 'object' || !input.adapt) {
+					let message = `${keypath} should be an object with an "adapt" method`;
+
+					if (Array.isArray(input) || typeof input === 'string') {
+						// for the early adapter adopters
+						message += ', rather than the name of an adapter';
+					}
+
+					throw new Error(`${message}. See https://kit.svelte.dev/docs/adapters`);
+				}
+
+				return input;
+			}),
+
+			alias: validate({}, (input, keypath) => {
+				if (typeof input !== 'object') {
+					throw new Error(`${keypath} should be an object`);
+				}
+
+				for (const key in input) {
+					assert_string(input[key], `${keypath}.${key}`);
+				}
+
+				return input;
+			}),
+
+			// TODO: remove this for the 1.0 release
+			amp: error(
+				(keypath) =>
+					`${keypath} has been removed. See https://kit.svelte.dev/docs/seo#amp for details on how to support AMP`
+			),
+
+			appDir: validate('_app', (input, keypath) => {
+				assert_string(input, keypath);
+
+				if (input) {
+					if (input.startsWith('/') || input.endsWith('/')) {
+						throw new Error(
+							"config.kit.appDir cannot start or end with '/'. See https://kit.svelte.dev/docs/configuration"
+						);
+					}
+				} else {
+					throw new Error(`${keypath} cannot be empty`);
+				}
+
+				return input;
+			}),
+
+			browser: validate({ hydrate: true, router: true }, (input, keypath) => {
+				const value = object({ hydrate: boolean(true), router: boolean(true) })(input, keypath);
+				if (!value.hydrate && value.router) {
+					throw new Error(
+						'config.kit.browser.router cannot be true if config.kit.browser.hydrate is false'
+					);
+				}
+				return value;
+			}),
+
+			csp: object({
+				mode: list(['auto', 'hash', 'nonce']),
+				directives,
+				reportOnly: directives
+			}),
+
+			// TODO: remove this for the 1.0 release
+			endpointExtensions: error(
+				(keypath) => `${keypath} has been renamed to config.kit.moduleExtensions`
+			),
+
+			env: object({
+				dir: string(process.cwd()),
+				publicPrefix: string('PUBLIC_')
+			}),
+
+			files: object({
+				assets: string('static'),
+				hooks: string(join('src', 'hooks')),
+				lib: string(join('src', 'lib')),
+				params: string(join('src', 'params')),
+				routes: string(join('src', 'routes')),
+				serviceWorker: string(join('src', 'service-worker')),
+				template: string(join('src', 'app.html'))
+			}),
+
+			// TODO: remove this for the 1.0 release
+			headers: error(
+				(keypath) =>
+					`${keypath} has been removed. See https://github.com/sveltejs/kit/pull/3384 for details`
+			),
+
+			// TODO: remove this for the 1.0 release
+			host: error(
+				(keypath) =>
+					`${keypath} has been removed. See https://github.com/sveltejs/kit/pull/3384 for details`
+			),
+
+			// TODO remove for 1.0
+			hydrate: error((keypath) => `${keypath} has been moved to config.kit.browser.hydrate`),
+
+			inlineStyleThreshold: number(0),
+
+			methodOverride: object({
+				parameter: string('_method'),
+				allowed: validate([], (input, keypath) => {
+					if (!Array.isArray(input) || !input.every((method) => typeof method === 'string')) {
+						throw new Error(`${keypath} must be an array of strings`);
+					}
+
+					if (input.map((i) => i.toUpperCase()).includes('GET')) {
+						throw new Error(`${keypath} cannot contain "GET"`);
+					}
+
+					return input;
+				})
+			}),
+
+			moduleExtensions: string_array(['.js', '.ts']),
+
+			outDir: string('.svelte-kit'),
+
+			package: error((keypath) => `${keypath} has been removed — use @sveltejs/package instead`),
+
+			paths: object({
+				base: validate('', (input, keypath) => {
+					assert_string(input, keypath);
+
+					if (input !== '' && (input.endsWith('/') || !input.startsWith('/'))) {
+						throw new Error(
+							`${keypath} option must either be the empty string or a root-relative path that starts but doesn't end with '/'. See https://kit.svelte.dev/docs/configuration#paths`
+						);
+					}
+
+					return input;
+				}),
+				assets: validate('', (input, keypath) => {
+					assert_string(input, keypath);
+
+					if (input) {
+						if (!/^[a-z]+:\/\//.test(input)) {
+							throw new Error(
+								`${keypath} option must be an absolute path, if specified. See https://kit.svelte.dev/docs/configuration#paths`
+							);
+						}
+
+						if (input.endsWith('/')) {
+							throw new Error(
+								`${keypath} option must not end with '/'. See https://kit.svelte.dev/docs/configuration#paths`
+							);
+						}
+					}
+
+					return input;
+				})
+			}),
+
+			prerender: object({
+				concurrency: number(1),
+				crawl: boolean(true),
+				createIndexFiles: error(
+					(keypath) =>
+						`${keypath} has been removed — it is now controlled by the trailingSlash option. See https://kit.svelte.dev/docs/configuration#trailingslash`
+				),
+				default: boolean(false),
+				enabled: boolean(true),
+				entries: validate(['*'], (input, keypath) => {
+					if (!Array.isArray(input) || !input.every((page) => typeof page === 'string')) {
+						throw new Error(`${keypath} must be an array of strings`);
+					}
+
+					input.forEach((page) => {
+						if (page !== '*' && page[0] !== '/') {
+							throw new Error(
+								`Each member of ${keypath} must be either '*' or an absolute path beginning with '/' — saw '${page}'`
+							);
+						}
+					});
+
+					return input;
+				}),
+
+				// TODO: remove this for the 1.0 release
+				force: validate(undefined, (input, keypath) => {
+					if (typeof input !== 'undefined') {
+						const newSetting = input ? 'continue' : 'fail';
+						const needsSetting = newSetting === 'continue';
+						throw new Error(
+							`${keypath} has been removed in favor of \`onError\`. In your case, set \`onError\` to "${newSetting}"${
+								needsSetting ? '' : ' (or leave it undefined)'
+							} to get the same behavior as you would with \`force: ${JSON.stringify(input)}\``
+						);
+					}
+				}),
+
+				onError: validate('fail', (input, keypath) => {
+					if (typeof input === 'function') return input;
+					if (['continue', 'fail'].includes(input)) return input;
+					throw new Error(
+						`${keypath} should be either a custom function or one of "continue" or "fail"`
+					);
+				}),
+
+				origin: validate('http://sveltekit-prerender', (input, keypath) => {
+					assert_string(input, keypath);
+
+					let origin;
+
+					try {
+						origin = new URL(input).origin;
+					} catch (e) {
+						throw new Error(`${keypath} must be a valid origin`);
+					}
+
+					if (input !== origin) {
+						throw new Error(`${keypath} must be a valid origin (${origin} rather than ${input})`);
+					}
+
+					return origin;
+				}),
+
+				// TODO: remove this for the 1.0 release
+				pages: error((keypath) => `${keypath} has been renamed to \`entries\`.`)
+			}),
+
+			// TODO: remove this for the 1.0 release
+			protocol: error(
+				(keypath) =>
+					`${keypath} has been removed. See https://github.com/sveltejs/kit/pull/3384 for details`
+			),
+
+			// TODO remove for 1.0
+			router: error((keypath) => `${keypath} has been moved to config.kit.browser.router`),
+
+			// TODO remove for 1.0
+			routes: error(
+				(keypath) =>
+					`${keypath} has been removed. See https://github.com/sveltejs/kit/discussions/5774 for details`
+			),
+
+			serviceWorker: object({
+				register: boolean(true),
+				files: fun((filename) => !/\.DS_Store/.test(filename))
+			}),
+
+			// TODO remove this for 1.0
+			ssr: error(
+				(keypath) =>
+					`${keypath} has been removed — use the handle hook instead: https://kit.svelte.dev/docs/hooks#handle`
+			),
+
+			// TODO remove this for 1.0
+			target: error((keypath) => `${keypath} is no longer required, and should be removed`),
+
+			trailingSlash: list(['never', 'always', 'ignore']),
+
+			version: object({
+				name: string(Date.now().toString()),
+				pollInterval: number(0)
+			}),
+
+			// TODO remove this for 1.0
+			vite: error((keypath) => `${keypath} has been removed — use vite.config.js instead`)
+		})
+	},
+	true
+);
+
+/**
+ * @param {Record<string, Validator>} children
+ * @param {boolean} [allow_unknown]
+ * @returns {Validator}
+ */
+function object(children, allow_unknown = false) {
+	return (input, keypath) => {
+		/** @type {Record<string, any>} */
+		const output = {};
+
+		if ((input && typeof input !== 'object') || Array.isArray(input)) {
+			throw new Error(`${keypath} should be an object`);
+		}
+
+		for (const key in input) {
+			if (!(key in children)) {
+				if (allow_unknown) {
+					output[key] = input[key];
+				} else {
+					let message = `Unexpected option ${keypath}.${key}`;
+
+					// special case
+					if (keypath === 'config.kit' && key in options) {
+						message += ` (did you mean config.${key}?)`;
+					}
+
+					throw new Error(message);
+				}
+			}
+		}
+
+		for (const key in children) {
+			const validator = children[key];
+			output[key] = validator(input && input[key], `${keypath}.${key}`);
+		}
+
+		return output;
+	};
+}
+
+/**
+ * @param {any} fallback
+ * @param {(value: any, keypath: string) => any} fn
+ * @returns {Validator}
+ */
+function validate(fallback, fn) {
+	return (input, keypath) => {
+		return input === undefined ? fallback : fn(input, keypath);
+	};
+}
+
+/**
+ * @param {string | null} fallback
+ * @param {boolean} allow_empty
+ * @returns {Validator}
+ */
+function string(fallback, allow_empty = true) {
+	return validate(fallback, (input, keypath) => {
+		assert_string(input, keypath);
+
+		if (!allow_empty && input === '') {
+			throw new Error(`${keypath} cannot be empty`);
+		}
+
+		return input;
+	});
+}
+
+/**
+ * @param {string[] | undefined} [fallback]
+ * @returns {Validator}
+ */
+function string_array(fallback) {
+	return validate(fallback, (input, keypath) => {
+		if (input === undefined) return input;
+
+		if (!Array.isArray(input) || input.some((value) => typeof value !== 'string')) {
+			throw new Error(`${keypath} must be an array of strings, if specified`);
+		}
+
+		return input;
+	});
+}
+
+/**
+ * @param {number} fallback
+ * @returns {Validator}
+ */
+function number(fallback) {
+	return validate(fallback, (input, keypath) => {
+		if (typeof input !== 'number') {
+			throw new Error(`${keypath} should be a number, if specified`);
+		}
+		return input;
+	});
+}
+
+/**
+ * @param {boolean} fallback
+ * @returns {Validator}
+ */
+function boolean(fallback) {
+	return validate(fallback, (input, keypath) => {
+		if (typeof input !== 'boolean') {
+			throw new Error(`${keypath} should be true or false, if specified`);
+		}
+		return input;
+	});
+}
+
+/**
+ * @param {string[]} options
+ * @returns {Validator}
+ */
+function list(options, fallback = options[0]) {
+	return validate(fallback, (input, keypath) => {
+		if (!options.includes(input)) {
+			// prettier-ignore
+			const msg = options.length > 2
+				? `${keypath} should be one of ${options.slice(0, -1).map(input => `"${input}"`).join(', ')} or "${options[options.length - 1]}"`
+				: `${keypath} should be either "${options[0]}" or "${options[1]}"`;
+
+			throw new Error(msg);
+		}
+		return input;
+	});
+}
+
+/**
+ * @param {(filename: string) => boolean} fallback
+ * @returns {Validator}
+ */
+function fun(fallback) {
+	return validate(fallback, (input, keypath) => {
+		if (typeof input !== 'function') {
+			throw new Error(`${keypath} should be a function, if specified`);
+		}
+		return input;
+	});
+}
+
+/**
+ * @param {string} input
+ * @param {string} keypath
+ */
+function assert_string(input, keypath) {
+	if (typeof input !== 'string') {
+		throw new Error(`${keypath} should be a string, if specified`);
+	}
+}
+
+/** @param {(keypath?: string) => string} fn */
+function error(fn) {
+	return validate(undefined, (input, keypath) => {
+		if (input !== undefined) {
+			throw new Error(fn(keypath));
+		}
+	});
+}
+
+export default options;

package/src/core/config/types.d.ts

@@ -0,0 +1 @@
+export type Validator<T = any> = (input: T, keypath: string) => T;

package/src/core/constants.js

@@ -0,0 +1,5 @@
+// in `vite dev` and `vite preview`, we use a fake asset path so that we can
+// serve local assets while verifying that requests are correctly prefixed
+export const SVELTE_KIT_ASSETS = '/_svelte_kit_assets';
+
+export const GENERATED_COMMENT = '// this file is generated — do not edit it\n';

package/src/core/env.js

@@ -0,0 +1,97 @@
+import { GENERATED_COMMENT } from './constants.js';
+import { runtime_base } from './utils.js';
+
+/**
+ * @param {string} id
+ * @param {Record<string, string>} env
+ * @returns {string}
+ */
+export function create_static_module(id, env) {
+	/** @type {string[]} */
+	const declarations = [];
+
+	for (const key in env) {
+		if (!valid_identifier.test(key) || reserved.has(key)) {
+			continue;
+		}
+
+		const comment = `/** @type {import('${id}').${key}} */`;
+		const declaration = `export const ${key} = ${JSON.stringify(env[key])};`;
+
+		declarations.push(`${comment}\n${declaration}`);
+	}
+
+	return GENERATED_COMMENT + declarations.join('\n\n');
+}
+
+/** @param {'public' | 'private'} type */
+export function create_dynamic_module(type) {
+	return `export { env } from '${runtime_base}/env-${type}.js';`;
+}
+
+/**
+ * @param {string} id
+ * @param {Record<string, string>} env
+ * @returns {string}
+ */
+export function create_types(id, env) {
+	const declarations = Object.keys(env)
+		.filter((k) => valid_identifier.test(k))
+		.map((k) => `\texport const ${k}: string;`)
+		.join('\n');
+
+	return `declare module '${id}' {\n${declarations}\n}`;
+}
+
+export const reserved = new Set([
+	'do',
+	'if',
+	'in',
+	'for',
+	'let',
+	'new',
+	'try',
+	'var',
+	'case',
+	'else',
+	'enum',
+	'eval',
+	'null',
+	'this',
+	'true',
+	'void',
+	'with',
+	'await',
+	'break',
+	'catch',
+	'class',
+	'const',
+	'false',
+	'super',
+	'throw',
+	'while',
+	'yield',
+	'delete',
+	'export',
+	'import',
+	'public',
+	'return',
+	'static',
+	'switch',
+	'typeof',
+	'default',
+	'extends',
+	'finally',
+	'package',
+	'private',
+	'continue',
+	'debugger',
+	'function',
+	'arguments',
+	'interface',
+	'protected',
+	'implements',
+	'instanceof'
+]);
+
+export const valid_identifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;

package/src/core/generate_manifest/index.js

@@ -0,0 +1,99 @@
+import { s } from '../../utils/misc.js';
+import { parse_route_id } from '../../utils/routing.js';
+import { get_mime_lookup } from '../utils.js';
+
+/**
+ * Generates the data used to write the server-side manifest.js file. This data is used in the Vite
+ * build process, to power routing, etc.
+ * @param {{
+ *   build_data: import('types').BuildData;
+ *   relative_path: string;
+ *   routes: import('types').RouteData[];
+ *   format?: 'esm' | 'cjs'
+ * }} opts
+ */
+export function generate_manifest({ build_data, relative_path, routes, format = 'esm' }) {
+	/** @typedef {{ index: number, path: string }} LookupEntry */
+	/** @type {Map<import('types').PageNode, LookupEntry>} */
+	const bundled_nodes = new Map();
+
+	build_data.manifest_data.nodes.forEach((node, i) => {
+		bundled_nodes.set(node, {
+			path: `${relative_path}/nodes/${i}.js`,
+			index: i
+		});
+	});
+
+	/** @type {(path: string) => string} */
+	const load =
+		format === 'esm'
+			? (path) => `import('${path}')`
+			: (path) => `Promise.resolve().then(() => require('${path}'))`;
+
+	/** @type {(path: string) => string} */
+	const loader = (path) => `() => ${load(path)}`;
+
+	const assets = build_data.manifest_data.assets.map((asset) => asset.file);
+	if (build_data.service_worker) {
+		assets.push(build_data.service_worker);
+	}
+
+	/** @param {import('types').PageNode | undefined} id */
+	const get_index = (id) => id && /** @type {LookupEntry} */ (bundled_nodes.get(id)).index;
+
+	const matchers = new Set();
+
+	// prettier-ignore
+	return `{
+		appDir: ${s(build_data.app_dir)},
+		assets: new Set(${s(assets)}),
+		mimeTypes: ${s(get_mime_lookup(build_data.manifest_data))},
+		_: {
+			entry: ${s(build_data.client.entry)},
+			nodes: [
+				${Array.from(bundled_nodes.values()).map(node => loader(node.path)).join(',\n\t\t\t\t')}
+			],
+			routes: [
+				${routes.map(route => {
+					const { pattern, names, types } = parse_route_id(route.id);
+
+					types.forEach(type => {
+						if (type) matchers.add(type);
+					});
+
+					if (route.type === 'page') {
+						return `{
+							type: 'page',
+							id: ${s(route.id)},
+							pattern: ${pattern},
+							names: ${s(names)},
+							types: ${s(types)},
+							errors: ${s(route.errors.map(get_index))},
+							layouts: ${s(route.layouts.map(get_index))},
+							leaf: ${s(get_index(route.leaf))}
+						}`.replace(/^\t\t/gm, '');
+					} else {
+						if (!build_data.server.vite_manifest[route.file]) {
+							// this is necessary in cases where a .css file snuck in —
+							// perhaps it would be better to disallow these (and others?)
+							return null;
+						}
+
+						return `{
+							type: 'endpoint',
+							id: ${s(route.id)},
+							pattern: ${pattern},
+							names: ${s(names)},
+							types: ${s(types)},
+							load: ${loader(`${relative_path}/${build_data.server.vite_manifest[route.file].file}`)}
+						}`.replace(/^\t\t/gm, '');
+					}
+				}).filter(Boolean).join(',\n\t\t\t\t')}
+			],
+			matchers: async () => {
+				${Array.from(matchers).map(type => `const { match: ${type} } = await ${load(`${relative_path}/entries/matchers/${type}.js`)}`).join('\n\t\t\t\t')}
+				return { ${Array.from(matchers).join(', ')} };
+			}
+		}
+	}`.replace(/^\t/gm, '');
+}