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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.0.0-next.428",
+  "version": "1.0.0-next.430",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",

package/src/core/config/options.js

@@ -129,6 +129,7 @@ const options = object(
 			),
 
 			env: object({
+				dir: string(process.cwd()),
 				publicPrefix: string('PUBLIC_')
 			}),
 

package/src/core/env.js

@@ -1,11 +1,12 @@
 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_module(id, env) {
+export function create_static_module(id, env) {
 	/** @type {string[]} */
 	const declarations = [];
 
@@ -23,6 +24,11 @@ export function create_module(id, env) {
 	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

package/src/core/sync/write_ambient.js

@@ -14,7 +14,7 @@ const types_reference = '/// <reference types="@sveltejs/kit" />\n\n';
  * @param {string} mode The Vite mode
  */
 export function write_ambient(config, mode) {
-	const env = get_env(mode, config.env.publicPrefix);
+	const env = get_env(config.env, mode);
 
 	write_if_changed(
 		path.join(config.outDir, 'ambient.d.ts'),

package/src/core/sync/write_tsconfig.js

@@ -46,7 +46,7 @@ export function write_tsconfig(config, cwd = process.cwd()) {
 	/** @param {string} file */
 	const config_relative = (file) => posixify(path.relative(config.outDir, file));
 
-	const include = ['ambient.d.ts'];
+	const include = ['ambient.d.ts', config_relative('vite.config.ts')];
 	for (const dir of [config.files.routes, config.files.lib]) {
 		const relative = project_relative(path.dirname(dir));
 		include.push(config_relative(`${relative}/**/*.js`));
@@ -80,7 +80,7 @@ export function write_tsconfig(config, cwd = process.cwd()) {
 					// script of a Svelte file. Therefore preserve all value imports. Requires TS 4.5 or higher.
 					preserveValueImports: true,
 
-					// This is required for svelte-kit package to work as expected
+					// This is required for svelte-package to work as expected
 					// Can be overwritten
 					lib: ['esnext', 'DOM', 'DOM.Iterable'],
 					moduleResolution: 'node',

package/src/core/utils.js

@@ -16,6 +16,18 @@ export const runtime_directory = posixify(fileURLToPath(new URL('../runtime', im
 /** Prefix for the `runtime` directory, for use with import declarations */
 export const runtime_prefix = posixify_path(runtime_directory);
 
+/**
+ * This allows us to import SvelteKit internals that aren't exposed via `pkg.exports` in a
+ * way that works whether `@sveltejs/kit` is installed inside the project's `node_modules`
+ * or in a workspace root
+ */
+export const runtime_base = runtime_directory.startsWith(process.cwd())
+	? `/${path.relative('.', runtime_directory)}`
+	: `/@fs${
+			// Windows/Linux separation - Windows starts with a drive letter, we need a / in front there
+			runtime_directory.startsWith('/') ? '' : '/'
+	  }${runtime_directory}`;
+
 /** @param {string} str */
 function posixify_path(str) {
 	const parsed = path.parse(str);

package/src/vite/dev/index.js

@@ -11,7 +11,7 @@ import { parse_route_id } from '../../utils/routing.js';
 import { load_template } from '../../core/config/index.js';
 import { SVELTE_KIT_ASSETS } from '../../core/constants.js';
 import * as sync from '../../core/sync/sync.js';
-import { get_mime_lookup, runtime_directory, runtime_prefix } from '../../core/utils.js';
+import { get_mime_lookup, runtime_base, runtime_prefix } from '../../core/utils.js';
 import { get_env, prevent_illegal_vite_imports, resolve_entry } from '../utils.js';
 
 // Vite doesn't expose this so we just copy the list for now
@@ -90,12 +90,7 @@ export async function dev(vite, vite_config, svelte_config, illegal_imports) {
 								module_nodes.push(module_node);
 								result.file = url.endsWith('.svelte') ? url : url + '?import'; // TODO what is this for?
 
-								prevent_illegal_vite_imports(
-									module_node,
-									illegal_imports,
-									extensions,
-									svelte_config.kit.outDir
-								);
+								prevent_illegal_vite_imports(module_node, illegal_imports, extensions);
 
 								return module.default;
 							};
@@ -108,12 +103,7 @@ export async function dev(vite, vite_config, svelte_config, illegal_imports) {
 
 							result.shared = module;
 
-							prevent_illegal_vite_imports(
-								module_node,
-								illegal_imports,
-								extensions,
-								svelte_config.kit.outDir
-							);
+							prevent_illegal_vite_imports(module_node, illegal_imports, extensions);
 						}
 
 						if (node.server) {
@@ -287,17 +277,10 @@ export async function dev(vite, vite_config, svelte_config, illegal_imports) {
 		}
 	});
 
-	const runtime_base = runtime_directory.startsWith(process.cwd())
-		? `/${path.relative('.', runtime_directory)}`
-		: `/@fs${
-				// Windows/Linux separation - Windows starts with a drive letter, we need a / in front there
-				runtime_directory.startsWith('/') ? '' : '/'
-		  }${runtime_directory}`;
-
 	const { set_private_env } = await vite.ssrLoadModule(`${runtime_base}/env-private.js`);
 	const { set_public_env } = await vite.ssrLoadModule(`${runtime_base}/env-public.js`);
 
-	const env = get_env(vite_config.mode, svelte_config.kit.env.publicPrefix);
+	const env = get_env(svelte_config.kit.env, vite_config.mode);
 	set_private_env(env.private);
 	set_public_env(env.public);
 

package/src/vite/index.js

@@ -16,7 +16,7 @@ import { find_deps, get_default_build_config } from './build/utils.js';
 import { preview } from './preview/index.js';
 import { get_aliases, resolve_entry, prevent_illegal_rollup_imports, get_env } from './utils.js';
 import { fileURLToPath } from 'node:url';
-import { create_module } from '../core/env.js';
+import { create_static_module, create_dynamic_module } from '../core/env.js';
 
 const cwd = process.cwd();
 
@@ -197,7 +197,7 @@ function kit() {
 		async config(config, config_env) {
 			vite_config_env = config_env;
 			svelte_config = await load_config();
-			env = get_env(vite_config_env.mode, svelte_config.kit.env.publicPrefix);
+			env = get_env(svelte_config.kit.env, vite_config_env.mode);
 
 			// The config is created in build_server for SSR mode and passed inline
 			if (config.build?.ssr) return;
@@ -211,8 +211,10 @@ function kit() {
 			};
 
 			illegal_imports = new Set([
-				vite.normalizePath(`${svelte_config.kit.outDir}/runtime/env/dynamic/private.js`),
-				vite.normalizePath(`${svelte_config.kit.outDir}/runtime/env/static/private.js`)
+				'/@id/__x00__$env/dynamic/private', //dev
+				'\0$env/dynamic/private', // prod
+				'/@id/__x00__$env/static/private', // dev
+				'\0$env/static/private' // prod
 			]);
 
 			if (is_build) {
@@ -285,15 +287,19 @@ function kit() {
 
 		async resolveId(id) {
 			// treat $env/static/[public|private] as virtual
-			if (id.startsWith('$env/static/')) return `\0${id}`;
+			if (id.startsWith('$env/')) return `\0${id}`;
 		},
 
 		async load(id) {
 			switch (id) {
 				case '\0$env/static/private':
-					return create_module('$env/static/private', env.private);
+					return create_static_module('$env/static/private', env.private);
 				case '\0$env/static/public':
-					return create_module('$env/static/public', env.public);
+					return create_static_module('$env/static/public', env.public);
+				case '\0$env/dynamic/private':
+					return create_dynamic_module('private');
+				case '\0$env/dynamic/public':
+					return create_dynamic_module('public');
 			}
 		},
 
@@ -345,8 +351,7 @@ function kit() {
 					prevent_illegal_rollup_imports(
 						this.getModuleInfo.bind(this),
 						module_node,
-						illegal_imports,
-						svelte_config.kit.outDir
+						illegal_imports
 					);
 				}
 			});

package/src/vite/utils.js

@@ -106,8 +106,6 @@ export function get_aliases(config) {
 	const alias = [
 		{ find: '__GENERATED__', replacement: path.posix.join(config.outDir, 'generated') },
 		{ find: '$app', replacement: `${runtime_directory}/app` },
-		{ find: '$env/dynamic/public', replacement: `${runtime_directory}/env/dynamic/public.js` },
-		{ find: '$env/dynamic/private', replacement: `${runtime_directory}/env/dynamic/private.js` },
 		// 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.
 		{ find: '$lib', replacement: config.files.lib }
@@ -185,13 +183,19 @@ function repeat(str, times) {
 /**
  * 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.join(out_dir, 'runtime/env');
+function format_illegal_import_chain(stack) {
+	const dev_virtual_prefix = '/@id/__x00__';
+	const prod_virtual_prefix = '\0';
 
 	stack = stack.map((file) => {
-		if (file.name.startsWith(app)) return { ...file, name: file.name.replace(app, '$env') };
+		if (file.name.startsWith(dev_virtual_prefix)) {
+			return { ...file, name: file.name.replace(dev_virtual_prefix, '') };
+		}
+		if (file.name.startsWith(prod_virtual_prefix)) {
+			return { ...file, name: file.name.replace(prod_virtual_prefix, '') };
+		}
+
 		return { ...file, name: path.relative(process.cwd(), file.name) };
 	});
 
@@ -209,15 +213,15 @@ function format_illegal_import_chain(stack, out_dir) {
 
 /**
  * Load environment variables from process.env and .env files
+ * @param {import('types').ValidatedKitConfig['env']} env_config
  * @param {string} mode
- * @param {string} prefix
  */
-export function get_env(mode, prefix) {
-	const entries = Object.entries(loadEnv(mode, process.cwd(), ''));
+export function get_env(env_config, mode) {
+	const entries = Object.entries(loadEnv(mode, env_config.dir, ''));
 
 	return {
-		public: Object.fromEntries(entries.filter(([k]) => k.startsWith(prefix))),
-		private: Object.fromEntries(entries.filter(([k]) => !k.startsWith(prefix)))
+		public: Object.fromEntries(entries.filter(([k]) => k.startsWith(env_config.publicPrefix))),
+		private: Object.fromEntries(entries.filter(([k]) => !k.startsWith(env_config.publicPrefix)))
 	};
 }
 
@@ -225,11 +229,17 @@ export function get_env(mode, prefix) {
  * @param {(id: string) => import('rollup').ModuleInfo | null} node_getter
  * @param {import('rollup').ModuleInfo} node
  * @param {Set<string>} illegal_imports Illegal module IDs -- be sure to call vite.normalizePath!
- * @param {string} out_dir The directory specified by config.kit.outDir
  */
-export function prevent_illegal_rollup_imports(node_getter, node, illegal_imports, out_dir) {
+export function prevent_illegal_rollup_imports(node_getter, node, illegal_imports) {
 	const chain = find_illegal_rollup_imports(node_getter, node, false, illegal_imports);
-	if (chain) throw new Error(format_illegal_import_chain(chain, out_dir));
+	if (chain) throw new Error(format_illegal_import_chain(chain));
+}
+
+const query_pattern = /\?.*$/s;
+
+/** @param {string} path */
+function remove_query_from_path(path) {
+	return path.replace(query_pattern, '');
 }
 
 /**
@@ -247,7 +257,7 @@ const find_illegal_rollup_imports = (
 	illegal_imports,
 	seen = new Set()
 ) => {
-	const name = normalizePath(node.id);
+	const name = remove_query_from_path(normalizePath(node.id));
 	if (seen.has(name)) return null;
 	seen.add(name);
 
@@ -300,11 +310,10 @@ const get_module_types = (config_module_types) => {
  * @param {import('vite').ModuleNode} node
  * @param {Set<string>} illegal_imports Illegal module IDs -- be sure to call vite.normalizePath!
  * @param {Iterable<string>} module_types File extensions to analyze in addition to the defaults: `.ts`, `.js`, etc.
- * @param {string} out_dir The directory specified by config.kit.outDir
  */
-export function prevent_illegal_vite_imports(node, illegal_imports, module_types, out_dir) {
+export function prevent_illegal_vite_imports(node, illegal_imports, module_types) {
 	const chain = find_illegal_vite_imports(node, illegal_imports, get_module_types(module_types));
-	if (chain) throw new Error(format_illegal_import_chain(chain, out_dir));
+	if (chain) throw new Error(format_illegal_import_chain(chain));
 }
 
 /**
@@ -316,9 +325,11 @@ export function prevent_illegal_vite_imports(node, illegal_imports, module_types
  */
 function find_illegal_vite_imports(node, illegal_imports, module_types, seen = new Set()) {
 	if (!node.id) return null; // TODO when does this happen?
-	const name = normalizePath(node.id);
+	const name = remove_query_from_path(normalizePath(node.id));
 
-	if (seen.has(name) || !module_types.has(path.extname(name))) return null;
+	if (path.extname(name) !== '' && (seen.has(name) || !module_types.has(path.extname(name)))) {
+		return null;
+	}
 	seen.add(name);
 
 	if (name && illegal_imports.has(name)) {

package/types/index.d.ts

@@ -131,7 +131,8 @@ export interface KitConfig {
 		reportOnly?: CspDirectives;
 	};
 	env?: {
-		publicPrefix: string;
+		dir?: string;
+		publicPrefix?: string;
 	};
 	moduleExtensions?: string[];
 	files?: {
@@ -248,7 +249,7 @@ export interface RequestEvent<
 }
 
 /**
- * A `(event: RequestEvent) => Response` function exported from a +server.js file that corresponds to an HTTP verb (`GET`, `PUT`, `PATCH`, etc) and handles requests with that method.
+ * A `(event: RequestEvent) => Response` function exported from a `+server.js` file that corresponds to an HTTP verb (`GET`, `PUT`, `PATCH`, etc) and handles requests with that method.
  *
  * It receives `Params` as the first generic argument, which you can skip by using [generated types](/docs/types#generated-types) instead.
  */