@sveltejs/kit 1.0.0-next.5 → 1.0.0-next.500

package/src/core/env.js

@@ -0,0 +1,121 @@
+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
+ * @param {Record<string, string> | undefined} dev_values If in a development mode, values to pre-populate the module with.
+ */
+export function create_dynamic_module(type, dev_values) {
+	if (dev_values) {
+		const objectKeys = Object.entries(dev_values).map(
+			([k, v]) => `${JSON.stringify(k)}: ${JSON.stringify(v)}`
+		);
+		return `const env = {\n${objectKeys.join(',\n')}\n}\n\nexport { env }`;
+	}
+	return `export { env } from '${runtime_base}/env-${type}.js';`;
+}
+
+/**
+ * @param {string} id
+ * @param {Record<string, string>} env
+ * @returns {string}
+ */
+export function create_static_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}`;
+}
+
+/**
+ * @param {string} id
+ * @param {Record<string, string>} env
+ * @returns {string}
+ */
+export function create_dynamic_types(id, env) {
+	const properties = Object.keys(env)
+		.filter((k) => valid_identifier.test(k))
+		.map((k) => `\t\t${k}: string;`);
+
+	properties.push(`\t\t[key: string]: string | undefined;`);
+
+	return `declare module '${id}' {\n\texport const env: {\n${properties.join('\n')}\n\t}\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,93 @@
+import { s } from '../../utils/misc.js';
+import { get_mime_lookup } from '../utils.js';
+import { resolve_symlinks } from '../../exports/vite/build/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);
+	}
+
+	const matchers = new Set();
+
+	// prettier-ignore
+	// String representation of
+	/** @type {import('types').SSRManifest} */
+	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 => {
+					route.types.forEach(type => {
+						if (type) matchers.add(type);
+					});
+
+					if (!route.page && !route.endpoint) return;
+
+					return `{
+					id: ${s(route.id)},
+					pattern: ${route.pattern},
+					names: ${s(route.names)},
+					types: ${s(route.types)},
+					page: ${route.page ? `{ layouts: ${get_nodes(route.page.layouts)}, errors: ${get_nodes(route.page.errors)}, leaf: ${route.page.leaf} }` : 'null'},
+					endpoint: ${route.endpoint ? loader(`${relative_path}/${resolve_symlinks(build_data.server.vite_manifest, route.endpoint.file).chunk.file}`) : 'null'}
+				}`;
+				}).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, '');
+}
+
+/** @param {Array<number | undefined>} indexes */
+function get_nodes(indexes) {
+	let string = indexes.map((n) => n ?? '').join(',');
+
+	if (indexes.at(-1) === undefined) {
+		// since JavaScript ignores trailing commas, we need to insert a dummy
+		// comma so that the array has the correct length if the last item
+		// is undefined
+		string += ',';
+	}
+
+	return `[${string}]`;
+}

package/src/core/prerender/crawl.js

@@ -0,0 +1,198 @@
+import { decode } from './entities.js';
+
+const DOCTYPE = 'DOCTYPE';
+const CDATA_OPEN = '[CDATA[';
+const CDATA_CLOSE = ']]>';
+const COMMENT_OPEN = '--';
+const COMMENT_CLOSE = '-->';
+
+const TAG_OPEN = /[a-zA-Z]/;
+const TAG_CHAR = /[a-zA-Z0-9]/;
+const ATTRIBUTE_NAME = /[^\t\n\f />"'=]/;
+
+const WHITESPACE = /[\s\n\r]/;
+
+/** @param {string} html */
+export function crawl(html) {
+	/** @type {string[]} */
+	const hrefs = [];
+
+	let i = 0;
+	main: while (i < html.length) {
+		const char = html[i];
+
+		if (char === '<') {
+			if (html[i + 1] === '!') {
+				i += 2;
+
+				if (html.slice(i, i + DOCTYPE.length).toUpperCase() === DOCTYPE) {
+					i += DOCTYPE.length;
+					while (i < html.length) {
+						if (html[i++] === '>') {
+							continue main;
+						}
+					}
+				}
+
+				// skip cdata
+				if (html.slice(i, i + CDATA_OPEN.length) === CDATA_OPEN) {
+					i += CDATA_OPEN.length;
+					while (i < html.length) {
+						if (html.slice(i, i + CDATA_CLOSE.length) === CDATA_CLOSE) {
+							i += CDATA_CLOSE.length;
+							continue main;
+						}
+
+						i += 1;
+					}
+				}
+
+				// skip comments
+				if (html.slice(i, i + COMMENT_OPEN.length) === COMMENT_OPEN) {
+					i += COMMENT_OPEN.length;
+					while (i < html.length) {
+						if (html.slice(i, i + COMMENT_CLOSE.length) === COMMENT_CLOSE) {
+							i += COMMENT_CLOSE.length;
+							continue main;
+						}
+
+						i += 1;
+					}
+				}
+			}
+
+			// parse opening tags
+			const start = ++i;
+			if (TAG_OPEN.test(html[start])) {
+				while (i < html.length) {
+					if (!TAG_CHAR.test(html[i])) {
+						break;
+					}
+
+					i += 1;
+				}
+
+				const tag = html.slice(start, i).toUpperCase();
+
+				if (tag === 'SCRIPT' || tag === 'STYLE') {
+					while (i < html.length) {
+						if (
+							html[i] === '<' &&
+							html[i + 1] === '/' &&
+							html.slice(i + 2, i + 2 + tag.length).toUpperCase() === tag
+						) {
+							continue main;
+						}
+
+						i += 1;
+					}
+				}
+
+				let href = '';
+				let rel = '';
+
+				while (i < html.length) {
+					const start = i;
+
+					const char = html[start];
+					if (char === '>') break;
+
+					if (ATTRIBUTE_NAME.test(char)) {
+						i += 1;
+
+						while (i < html.length) {
+							if (!ATTRIBUTE_NAME.test(html[i])) {
+								break;
+							}
+
+							i += 1;
+						}
+
+						const name = html.slice(start, i).toLowerCase();
+
+						while (WHITESPACE.test(html[i])) i += 1;
+
+						if (html[i] === '=') {
+							i += 1;
+							while (WHITESPACE.test(html[i])) i += 1;
+
+							let value;
+
+							if (html[i] === "'" || html[i] === '"') {
+								const quote = html[i++];
+
+								const start = i;
+								let escaped = false;
+
+								while (i < html.length) {
+									if (!escaped) {
+										const char = html[i];
+
+										if (html[i] === quote) {
+											break;
+										}
+
+										if (char === '\\') {
+											escaped = true;
+										}
+									}
+
+									i += 1;
+								}
+
+								value = html.slice(start, i);
+							} else {
+								const start = i;
+								while (html[i] !== '>' && !WHITESPACE.test(html[i])) i += 1;
+								value = html.slice(start, i);
+
+								i -= 1;
+							}
+
+							value = decode(value);
+
+							if (name === 'href') {
+								href = value;
+							} else if (name === 'rel') {
+								rel = value;
+							} else if (name === 'src') {
+								hrefs.push(value);
+							} else if (name === 'srcset') {
+								const candidates = [];
+								let insideURL = true;
+								value = value.trim();
+								for (let i = 0; i < value.length; i++) {
+									if (value[i] === ',' && (!insideURL || (insideURL && value[i + 1] === ' '))) {
+										candidates.push(value.slice(0, i));
+										value = value.substring(i + 1).trim();
+										i = 0;
+										insideURL = true;
+									} else if (value[i] === ' ') {
+										insideURL = false;
+									}
+								}
+								candidates.push(value);
+								for (const candidate of candidates) {
+									const src = candidate.split(WHITESPACE)[0];
+									hrefs.push(src);
+								}
+							}
+						} else {
+							i -= 1;
+						}
+					}
+
+					i += 1;
+				}
+
+				if (href && !/\bexternal\b/i.test(rel)) {
+					hrefs.push(href);
+				}
+			}
+		}
+
+		i += 1;
+	}
+
+	return hrefs;
+}