@sveltejs/kit 1.0.0-next.392 → 1.0.0-next.395

package/dist/chunks/index3.js

@@ -0,0 +1,218 @@
+import { $ } from './index.js';
+import { r as rimraf, m as mkdirp, c as copy } from './filesystem.js';
+import { g as generate_manifest } from '../vite.js';
+import 'fs';
+import 'path';
+import 'url';
+import 'node:child_process';
+import 'node:fs';
+import 'node:path';
+import '@sveltejs/vite-plugin-svelte';
+import 'vite';
+import './sync.js';
+import './utils.js';
+import './write_tsconfig.js';
+import 'querystring';
+import '../node.js';
+import '../node/polyfills.js';
+import 'assert';
+import 'net';
+import 'http';
+import 'stream';
+import 'buffer';
+import 'util';
+import 'stream/web';
+import 'perf_hooks';
+import 'util/types';
+import 'events';
+import 'tls';
+import 'async_hooks';
+import 'console';
+import 'zlib';
+import 'node:http';
+import 'node:https';
+import 'node:zlib';
+import 'node:stream';
+import 'node:buffer';
+import 'node:util';
+import 'node:url';
+import 'node:net';
+import 'crypto';
+import './error.js';
+
+/**
+ * Creates the Builder which is passed to adapters for building the application.
+ * @param {{
+ *   config: import('types').ValidatedConfig;
+ *   build_data: import('types').BuildData;
+ *   prerendered: import('types').Prerendered;
+ *   log: import('types').Logger;
+ * }} opts
+ * @returns {import('types').Builder}
+ */
+function create_builder({ config, build_data, prerendered, log }) {
+	/** @type {Set<string>} */
+	const prerendered_paths = new Set(prerendered.paths);
+
+	/** @param {import('types').RouteData} route */
+	// TODO routes should come pre-filtered
+	function not_prerendered(route) {
+		if (route.type === 'page' && route.path) {
+			return !prerendered_paths.has(route.path) && !prerendered_paths.has(route.path + '/');
+		}
+
+		return true;
+	}
+
+	return {
+		log,
+		rimraf,
+		mkdirp,
+		copy,
+
+		config,
+		prerendered,
+
+		async createEntries(fn) {
+			const { routes } = build_data.manifest_data;
+
+			/** @type {import('types').RouteDefinition[]} */
+			const facades = routes.map((route) => ({
+				id: route.id,
+				type: route.type,
+				segments: route.id.split('/').map((segment) => ({
+					dynamic: segment.includes('['),
+					rest: segment.includes('[...'),
+					content: segment
+				})),
+				pattern: route.pattern,
+				methods: route.type === 'page' ? ['GET'] : build_data.server.methods[route.file]
+			}));
+
+			const seen = new Set();
+
+			for (let i = 0; i < routes.length; i += 1) {
+				const route = routes[i];
+				const { id, filter, complete } = fn(facades[i]);
+
+				if (seen.has(id)) continue;
+				seen.add(id);
+
+				const group = [route];
+
+				// figure out which lower priority routes should be considered fallbacks
+				for (let j = i + 1; j < routes.length; j += 1) {
+					if (filter(facades[j])) {
+						group.push(routes[j]);
+					}
+				}
+
+				const filtered = new Set(group.filter(not_prerendered));
+
+				// heuristic: if /foo/[bar] is included, /foo/[bar].json should
+				// also be included, since the page likely needs the endpoint
+				filtered.forEach((route) => {
+					if (route.type === 'page') {
+						const endpoint = routes.find((candidate) => candidate.id === route.id + '.json');
+
+						if (endpoint) {
+							filtered.add(endpoint);
+						}
+					}
+				});
+
+				if (filtered.size > 0) {
+					await complete({
+						generateManifest: ({ relativePath, format }) =>
+							generate_manifest({
+								build_data,
+								relative_path: relativePath,
+								routes: Array.from(filtered),
+								format
+							})
+					});
+				}
+			}
+		},
+
+		generateManifest: ({ relativePath, format }) => {
+			return generate_manifest({
+				build_data,
+				relative_path: relativePath,
+				routes: build_data.manifest_data.routes.filter(not_prerendered),
+				format
+			});
+		},
+
+		getBuildDirectory(name) {
+			return `${config.kit.outDir}/${name}`;
+		},
+
+		getClientDirectory() {
+			return `${config.kit.outDir}/output/client`;
+		},
+
+		getServerDirectory() {
+			return `${config.kit.outDir}/output/server`;
+		},
+
+		getStaticDirectory() {
+			return config.kit.files.assets;
+		},
+
+		writeClient(dest) {
+			return [...copy(`${config.kit.outDir}/output/client`, dest)];
+		},
+
+		writePrerendered(dest, { fallback } = {}) {
+			const source = `${config.kit.outDir}/output/prerendered`;
+			const files = [...copy(`${source}/pages`, dest), ...copy(`${source}/dependencies`, dest)];
+
+			if (fallback) {
+				files.push(fallback);
+				copy(`${source}/fallback.html`, `${dest}/${fallback}`);
+			}
+
+			return files;
+		},
+
+		writeServer(dest) {
+			return copy(`${config.kit.outDir}/output/server`, dest);
+		},
+
+		// TODO remove these methods for 1.0
+		// @ts-expect-error
+		writeStatic() {
+			throw new Error(
+				`writeStatic has been removed. Please ensure you are using the latest version of ${
+					config.kit.adapter.name || 'your adapter'
+				}`
+			);
+		},
+
+		async prerender() {
+			throw new Error(
+				'builder.prerender() has been removed. Prerendering now takes place in the build phase — see builder.prerender and builder.writePrerendered'
+			);
+		}
+	};
+}
+
+/**
+ * @param {import('types').ValidatedConfig} config
+ * @param {import('types').BuildData} build_data
+ * @param {import('types').Prerendered} prerendered
+ * @param {{ log: import('types').Logger }} opts
+ */
+async function adapt(config, build_data, prerendered, { log }) {
+	const { name, adapt } = config.kit.adapter;
+
+	console.log($.bold().cyan(`\n> Using ${name}`));
+
+	const builder = create_builder({ config, build_data, prerendered, log });
+	await adapt(builder);
+
+	log.success('done');
+}
+
+export { adapt };

package/dist/chunks/sync.js

@@ -1,8 +1,11 @@
 import path__default from 'path';
 import fs__default from 'fs';
-import { $ } from './error.js';
+import { g as get_runtime_directory } from './utils.js';
+import { p as posixify, c as copy, r as rimraf } from './filesystem.js';
 import { fileURLToPath } from 'url';
-import { p as posixify, c as copy, a as write_if_changed, t as trim, r as rimraf, b as write, d as write_tsconfig } from './write_tsconfig.js';
+import { w as write_if_changed, t as trim, a as write, v as valid_identifier, r as reserved, b as write_tsconfig } from './write_tsconfig.js';
+import { $ } from './index.js';
+import { loadEnv, loadConfigFromFile } from 'vite';
 
 /**
  * @param typeMap [Object] Map of MIME type -> Array[extensions]
@@ -107,67 +110,6 @@ var other = {"application/prs.cww":["cww"],"application/vnd.1000minds.decision-m
 let Mime = Mime_1;
 var mime = new Mime(standard, other);
 
-/**
- * Get the prefix for the `runtime` directory, for use with import declarations
- * @param {import('types').ValidatedKitConfig} config
- */
-function get_runtime_prefix(config) {
-	{
-		return posixify_path(path__default.join(config.outDir, 'runtime'));
-	}
-}
-
-/**
- * Get the resolved path of the `runtime` directory
- * @param {import('types').ValidatedKitConfig} config
- */
-function get_runtime_directory(config) {
-	{
-		return path__default.join(config.outDir, 'runtime');
-	}
-}
-
-/** @param {string} str */
-function posixify_path(str) {
-	const parsed = path__default.parse(str);
-	return `/${parsed.dir.slice(parsed.root.length).split(path__default.sep).join('/')}/${parsed.base}`;
-}
-
-function noop() {}
-
-/** @param {{ verbose: boolean }} opts */
-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($.green(`✔ ${msg}`));
-	log.error = (msg) => err($.bold().red(msg));
-	log.warn = (msg) => log($.bold().yellow(msg));
-
-	log.minor = verbose ? (msg) => log($.grey(msg)) : noop;
-	log.info = verbose ? log : noop;
-
-	return log;
-}
-
-/** @param {import('types').ManifestData} manifest_data */
-function get_mime_lookup(manifest_data) {
-	/** @type {Record<string, string>} */
-	const mime = {};
-
-	manifest_data.assets.forEach((asset) => {
-		if (asset.type) {
-			const ext = path__default.extname(asset.file);
-			mime[ext] = asset.type;
-		}
-	});
-
-	return mime;
-}
-
 const param_pattern = /^(\.\.\.)?(\w+)(?:=(\w+))?$/;
 
 /** @param {string} id */
@@ -970,13 +912,374 @@ function write_types(config, manifest_data) {
 	});
 }
 
-/** @param {import('types').ValidatedConfig} config */
-function init(config) {
+/**
+ * @param {import('vite').ResolvedConfig} config
+ * @param {import('vite').ConfigEnv} config_env
+ * @return {Promise<import('vite').UserConfig>}
+ */
+async function get_vite_config(config, config_env) {
+	const loaded = await loadConfigFromFile(
+		config_env,
+		config.configFile,
+		undefined,
+		config.logLevel
+	);
+
+	if (!loaded) {
+		throw new Error('Could not load Vite config');
+	}
+	return { ...loaded.config, mode: config_env.mode };
+}
+
+/**
+ * @param {...import('vite').UserConfig} configs
+ * @returns {import('vite').UserConfig}
+ */
+function merge_vite_configs(...configs) {
+	return deep_merge(
+		...configs.map((config) => ({
+			...config,
+			resolve: {
+				...config.resolve,
+				alias: normalize_alias(config.resolve?.alias || {})
+			}
+		}))
+	);
+}
+
+/**
+ * Takes zero or more objects and returns a new object that has all the values
+ * deeply merged together. None of the original objects will be mutated at any
+ * level, and the returned object will have no references to the original
+ * objects at any depth. If there's a conflict the last one wins, except for
+ * arrays which will be combined.
+ * @param {...Object} objects
+ * @returns {Record<string, any>} the merged object
+ */
+function deep_merge(...objects) {
+	const result = {};
+	/** @type {string[]} */
+	objects.forEach((o) => merge_into(result, o));
+	return result;
+}
+
+/**
+ * normalize kit.vite.resolve.alias as an array
+ * @param {import('vite').AliasOptions} o
+ * @returns {import('vite').Alias[]}
+ */
+function normalize_alias(o) {
+	if (Array.isArray(o)) return o;
+	return Object.entries(o).map(([find, replacement]) => ({ find, replacement }));
+}
+
+/**
+ * Merges b into a, recursively, mutating a.
+ * @param {Record<string, any>} a
+ * @param {Record<string, any>} b
+ */
+function merge_into(a, b) {
+	/**
+	 * Checks for "plain old Javascript object", typically made as an object
+	 * literal. Excludes Arrays and built-in types like Buffer.
+	 * @param {any} x
+	 */
+	const is_plain_object = (x) => typeof x === 'object' && x.constructor === Object;
+
+	for (const prop in b) {
+		if (is_plain_object(b[prop])) {
+			if (!is_plain_object(a[prop])) {
+				a[prop] = {};
+			}
+			merge_into(a[prop], b[prop]);
+		} else if (Array.isArray(b[prop])) {
+			if (!Array.isArray(a[prop])) {
+				a[prop] = [];
+			}
+			a[prop].push(...b[prop]);
+		} else {
+			a[prop] = b[prop];
+		}
+	}
+}
+
+/** @param {import('types').ValidatedKitConfig} config */
+function get_aliases(config) {
+	/** @type {Record<string, string>} */
+	const alias = {
+		__GENERATED__: path__default.posix.join(config.outDir, 'generated'),
+
+		$app: `${get_runtime_directory(config)}/app`,
+
+		// For now, we handle `$lib` specially here rather than make it a default value for
+		// `config.kit.alias` since it has special meaning for packaging, etc.
+		$lib: config.files.lib
+	};
+
+	alias['$env'] = `${get_runtime_directory(config)}/env`;
+
+	for (const [key, value] of Object.entries(config.alias)) {
+		alias[key] = path__default.resolve(value);
+	}
+
+	return alias;
+}
+
+/**
+ * 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}
+ */
+function resolve_entry(entry) {
+	if (fs__default.existsSync(entry)) {
+		const stats = fs__default.statSync(entry);
+		if (stats.isDirectory()) {
+			return resolve_entry(path__default.join(entry, 'index'));
+		}
+
+		return entry;
+	} else {
+		const dir = path__default.dirname(entry);
+
+		if (fs__default.existsSync(dir)) {
+			const base = path__default.basename(entry);
+			const files = fs__default.readdirSync(dir);
+
+			const found = files.find((file) => file.replace(/\.[^.]+$/, '') === base);
+
+			if (found) return path__default.join(dir, found);
+		}
+	}
+
+	return null;
+}
+
+/**
+ * @param {string} str
+ * @param {number} times
+ */
+function repeat(str, times) {
+	return new Array(times + 1).join(str);
+}
+
+/**
+ * Create a formatted error for an illegal import.
+ * @param {Array<{name: string, dynamic: boolean}>} stack
+ * @param {string} out_dir The directory specified by config.kit.outDir
+ */
+function format_illegal_import_chain(stack, out_dir) {
+	const app = path__default.join(out_dir, 'runtime/env');
+
+	stack = stack.map((file) => {
+		if (file.name.startsWith(app)) return { ...file, name: file.name.replace(app, '$env') };
+		return { ...file, name: path__default.relative(process.cwd(), file.name) };
+	});
+
+	const pyramid = stack
+		.map(
+			(file, i) =>
+				`${repeat(' ', i * 2)}- ${file.name} ${
+					file.dynamic ? '(imported by parent dynamically)' : ''
+				}`
+		)
+		.join('\n');
+
+	return `Cannot import ${stack.at(-1)?.name} into client-side code:\n${pyramid}`;
+}
+
+/**
+ * Load environment variables from process.env and .env files
+ * @param {string} mode
+ * @param {string} prefix
+ */
+function get_env(mode, prefix) {
+	const entries = Object.entries(loadEnv(mode, process.cwd(), ''));
+
+	return {
+		public: Object.fromEntries(entries.filter(([k]) => k.startsWith(prefix))),
+		private: Object.fromEntries(entries.filter(([k]) => !k.startsWith(prefix)))
+	};
+}
+
+/**
+ * @param {(id: string) => import('rollup').ModuleInfo | null} node_getter
+ * @param {import('rollup').ModuleInfo} node
+ * @param {Set<string>} illegal_imports
+ * @param {string} out_dir The directory specified by config.kit.outDir
+ */
+function prevent_illegal_rollup_imports(node_getter, node, illegal_imports, out_dir) {
+	const chain = find_illegal_rollup_imports(node_getter, node, false, illegal_imports);
+	if (chain) throw new Error(format_illegal_import_chain(chain, out_dir));
+}
+
+/**
+ * @param {(id: string) => import('rollup').ModuleInfo | null} node_getter
+ * @param {import('rollup').ModuleInfo} node
+ * @param {boolean} dynamic
+ * @param {Set<string>} illegal_imports
+ * @param {Set<string>} seen
+ * @returns {Array<import('types').ImportNode> | undefined}
+ */
+const find_illegal_rollup_imports = (
+	node_getter,
+	node,
+	dynamic,
+	illegal_imports,
+	seen = new Set()
+) => {
+	if (seen.has(node.id)) return;
+	seen.add(node.id);
+
+	if (illegal_imports.has(node.id)) {
+		return [{ name: node.id, dynamic }];
+	}
+
+	for (const id of node.importedIds) {
+		const child = node_getter(id);
+		const chain =
+			child && find_illegal_rollup_imports(node_getter, child, false, illegal_imports, seen);
+		if (chain) return [{ name: node.id, dynamic }, ...chain];
+	}
+
+	for (const id of node.dynamicallyImportedIds) {
+		const child = node_getter(id);
+		const chain =
+			child && find_illegal_rollup_imports(node_getter, child, true, illegal_imports, seen);
+		if (chain) return [{ name: node.id, dynamic }, ...chain];
+	}
+};
+
+/**
+ * Throw an error if a private module is imported from a client-side node.
+ * @param {import('vite').ModuleNode} node
+ * @param {Set<string>} illegal_imports
+ * @param {string} out_dir The directory specified by config.kit.outDir
+ */
+function prevent_illegal_vite_imports(node, illegal_imports, out_dir) {
+	const chain = find_illegal_vite_imports(node, illegal_imports);
+	if (chain) throw new Error(format_illegal_import_chain(chain, out_dir));
+}
+
+/**
+ * @param {import('vite').ModuleNode} node
+ * @param {Set<string>} illegal_imports
+ * @param {Set<string>} seen
+ * @returns {Array<import('types').ImportNode> | null}
+ */
+function find_illegal_vite_imports(node, illegal_imports, seen = new Set()) {
+	if (!node.id) return null; // TODO when does this happen?
+
+	if (seen.has(node.id)) return null;
+	seen.add(node.id);
+
+	if (node.id && illegal_imports.has(node.id)) {
+		return [{ name: node.id, dynamic: false }];
+	}
+
+	for (const child of node.importedModules) {
+		const chain = child && find_illegal_vite_imports(child, illegal_imports, seen);
+		if (chain) return [{ name: node.id, dynamic: false }, ...chain];
+	}
+
+	return null;
+}
+
+const autogen_comment = '// this file is generated — do not edit it\n';
+
+/**
+ * Writes the existing environment variables in process.env to
+ * $env/static/private and $env/static/public
+ * @param {import('types').ValidatedKitConfig} config
+ * @param {string} mode The Vite mode
+ */
+function write_env(config, mode) {
+	const env = get_env(mode, config.env.publicPrefix);
+
+	// TODO when testing src, `$app` points at `src/runtime/app`... will
+	// probably need to fiddle with aliases
+	write_if_changed(
+		path__default.join(config.outDir, 'runtime/env/static/public.js'),
+		create_module('$env/static/public', env.public)
+	);
+
+	write_if_changed(
+		path__default.join(config.outDir, 'runtime/env/static/private.js'),
+		create_module('$env/static/private', env.private)
+	);
+
+	write_if_changed(
+		path__default.join(config.outDir, 'ambient.d.ts'),
+		autogen_comment +
+			create_types('$env/static/public', env.public) +
+			'\n\n' +
+			create_types('$env/static/private', env.private)
+	);
+}
+
+/**
+ * @param {string} id
+ * @param {Record<string, string>} env
+ * @returns {string}
+ */
+function create_module(id, env) {
+	/** @type {string[]} */
+	const declarations = [];
+
+	for (const key in env) {
+		const warning = !valid_identifier.test(key)
+			? 'not a valid identifier'
+			: reserved.has(key)
+			? 'a reserved word'
+			: null;
+
+		if (warning) {
+			console.error(
+				$
+					.bold()
+					.yellow(`Omitting environment variable "${key}" from ${id} as it is ${warning}`)
+			);
+			continue;
+		}
+
+		const comment = `/** @type {import('${id}'}').${key}} */`;
+		const declaration = `export const ${key} = ${JSON.stringify(env[key])};`;
+
+		declarations.push(`${comment}\n${declaration}`);
+	}
+
+	return autogen_comment + declarations.join('\n\n');
+}
+
+/**
+ * @param {string} id
+ * @param {Record<string, string>} env
+ * @returns {string}
+ */
+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}`;
+}
+
+/**
+ * Initialize SvelteKit's generated files.
+ * @param {import('types').ValidatedConfig} config
+ * @param {string} mode
+ */
+function init(config, mode) {
 	copy_assets(path__default.join(config.kit.outDir, 'runtime'));
+
 	write_tsconfig(config.kit);
+	write_env(config.kit, mode);
 }
 
-/** @param {import('types').ValidatedConfig} config */
+/**
+ * Update SvelteKit's generated files.
+ * @param {import('types').ValidatedConfig} config
+ */
 function update(config) {
 	const manifest_data = create_manifest_data({ config });
 
@@ -991,9 +1294,13 @@ function update(config) {
 	return { manifest_data };
 }
 
-/** @param {import('types').ValidatedConfig} config */
-function all(config) {
-	init(config);
+/**
+ * Run sync.init and sync.update in series, returning the result from sync.update.
+ * @param {import('types').ValidatedConfig} config
+ * @param {string} mode The Vite mode
+ */
+function all(config, mode) {
+	init(config, mode);
 	return update(config);
 }
 
@@ -1004,4 +1311,4 @@ var sync = /*#__PURE__*/Object.freeze({
   all: all
 });
 
-export { get_runtime_prefix as a, get_mime_lookup as b, all as c, sync as d, get_runtime_directory as g, init as i, logger as l, parse_route_id as p, s, update as u };
+export { get_vite_config as a, get_env as b, parse_route_id as c, all as d, prevent_illegal_rollup_imports as e, sync as f, get_aliases as g, init as i, merge_vite_configs as m, prevent_illegal_vite_imports as p, resolve_entry as r, s, update as u };