@sveltejs/kit 1.0.0-next.438 → 1.0.0-next.440

package/package.json

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

package/src/core/sync/create_manifest_data/index.js

@@ -180,7 +180,7 @@ function create_routes_and_nodes(cwd, config, fallback) {
 							component: project_relative
 						};
 					} else if (item.is_layout) {
-						if (!route.layout) route.layout = { depth };
+						if (!route.layout) route.layout = { depth, child_pages: [] };
 						route.layout.component = project_relative;
 						if (item.uses_layout !== undefined) route.layout.parent_id = item.uses_layout;
 					} else {
@@ -189,7 +189,7 @@ function create_routes_and_nodes(cwd, config, fallback) {
 						if (item.uses_layout !== undefined) route.leaf.parent_id = item.uses_layout;
 					}
 				} else if (item.is_layout) {
-					if (!route.layout) route.layout = { depth };
+					if (!route.layout) route.layout = { depth, child_pages: [] };
 					route.layout[item.kind] = project_relative;
 				} else if (item.is_page) {
 					if (!route.leaf) route.leaf = { depth };
@@ -223,7 +223,7 @@ function create_routes_and_nodes(cwd, config, fallback) {
 		}
 
 		if (!root.layout?.component) {
-			if (!root.layout) root.layout = { depth: 0 };
+			if (!root.layout) root.layout = { depth: 0, child_pages: [] };
 			root.layout.component = posixify(path.relative(cwd, `${fallback}/layout.svelte`));
 		}
 
@@ -290,6 +290,9 @@ function create_routes_and_nodes(cwd, config, fallback) {
 					}
 
 					if (current_route.layout) {
+						/** @type {import('types').PageNode[]} */ (current_route.layout.child_pages).push(
+							route.leaf
+						);
 						current_node.parent = current_node = current_route.layout;
 						parent_id = current_node.parent_id;
 					} else {

package/src/core/sync/sync.js

@@ -4,7 +4,7 @@ import { write_client_manifest } from './write_client_manifest.js';
 import { write_matchers } from './write_matchers.js';
 import { write_root } from './write_root.js';
 import { write_tsconfig } from './write_tsconfig.js';
-import { write_types, write_all_types } from './write_types.js';
+import { write_types, write_all_types } from './write_types/index.js';
 import { write_ambient } from './write_ambient.js';
 
 /**

package/src/core/sync/write_client_manifest.js

@@ -53,17 +53,13 @@ export function write_client_manifest(manifest_data, output) {
 					while (layouts.at(-1) === '') layouts.pop();
 					while (errors.at(-1) === '') errors.pop();
 
-					/** @type {import('types').RouteData | null} */
-					let current_route = route;
-
 					/** @type {import('types').PageNode | null} */
 					let current_node = route.leaf;
 
 					let uses_server_data = false;
-					while (current_route && !uses_server_data) {
+					while (current_node && !uses_server_data) {
 						uses_server_data = !!current_node?.server;
-						current_route = current_route.parent;
-						current_node = current_route?.layout ?? null;
+						current_node = current_node?.parent ?? null;
 					}
 
 					// encode whether or not the route uses the server data

package/src/core/sync/{write_types.js → write_types/index.js}

@@ -1,8 +1,8 @@
 import fs from 'fs';
 import path from 'path';
 import MagicString from 'magic-string';
-import { posixify, rimraf, walk } from '../../utils/filesystem.js';
-import { compact } from '../../utils/array.js';
+import { posixify, rimraf, walk } from '../../../utils/filesystem.js';
+import { compact } from '../../../utils/array.js';
 
 /**
  *  @typedef {{
@@ -49,9 +49,10 @@ export async function write_all_types(config, manifest_data) {
 		}
 	}
 
+	const routes_map = create_routes_map(manifest_data);
 	// For each directory, write $types.d.ts
 	for (const route of manifest_data.routes) {
-		update_types(config, manifest_data, route);
+		update_types(config, routes_map, route);
 	}
 }
 
@@ -76,16 +77,33 @@ export async function write_types(config, manifest_data, file) {
 	const route = manifest_data.routes.find((route) => route.id === id);
 	if (!route) return; // this shouldn't ever happen
 
-	update_types(config, manifest_data, route);
+	update_types(config, create_routes_map(manifest_data), route);
 }
 
 /**
- *
- * @param {import('types').ValidatedConfig} config
+ * Collect all leafs into a leaf -> route map
  * @param {import('types').ManifestData} manifest_data
+ */
+function create_routes_map(manifest_data) {
+	/** @type {Map<import('types').PageNode, import('types').RouteData>} */
+	const map = new Map();
+	for (const route of manifest_data.routes) {
+		if (route.leaf) {
+			map.set(route.leaf, route);
+		}
+	}
+	return map;
+}
+
+/**
+ * Update types for a specific route
+ * @param {import('types').ValidatedConfig} config
+ * @param {Map<import('types').PageNode, import('types').RouteData>} routes
  * @param {import('types').RouteData} route
  */
-function update_types(config, manifest_data, route) {
+function update_types(config, routes, route) {
+	if (!route.leaf && !route.layout && !route.endpoint) return; // nothing to do
+
 	const routes_dir = posixify(path.relative('.', config.kit.files.routes));
 	const outdir = path.join(config.kit.outDir, 'types', routes_dir, route.id);
 
@@ -112,8 +130,6 @@ function update_types(config, manifest_data, route) {
 		input_files.push(route.endpoint.file);
 	}
 
-	if (!route.leaf && !route.layout && !route.endpoint) return; // nothing to do
-
 	try {
 		fs.mkdirSync(outdir, { recursive: true });
 	} catch {}
@@ -138,6 +154,7 @@ function update_types(config, manifest_data, route) {
 	// track which old files end up being surplus to requirements
 	const to_delete = new Set(output_files.map((file) => file.name));
 
+	// now generate new types
 	const imports = [`import type * as Kit from '@sveltejs/kit';`];
 
 	/** @type {string[]} */
@@ -146,41 +163,29 @@ function update_types(config, manifest_data, route) {
 	/** @type {string[]} */
 	const exports = [];
 
-	if (route.names.length > 0) {
-		const params = route.names.map((param) => `${param}: string`).join('; ');
+	declarations.push(
+		`type RouteParams = { ${route.names.map((param) => `${param}: string`).join('; ')} }`
+	);
+
+	if (route.layout || route.leaf) {
+		// These could also be placed in our public types, but it would bloat them unnecessarily and we may want to change these in the future
+		declarations.push(`type MaybeWithVoid<T> = {} extends T ? T | void : T;`);
 		declarations.push(
-			`interface RouteParams extends Partial<Record<string, string>> { ${params} }`
+			`export type RequiredKeys<T> = { [K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K; }[keyof T];`
 		);
-	} else {
-		declarations.push(`interface RouteParams extends Partial<Record<string, string>> {}`);
+		declarations.push(
+			`type OutputDataShape<T> = MaybeWithVoid<Omit<App.PageData, RequiredKeys<T>> & Partial<Pick<App.PageData, keyof T & keyof App.PageData>> & Record<string, any>>`
+		);
+		declarations.push(`type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;`);
 	}
 
 	if (route.leaf) {
-		const { data, server_data, load, server_load, errors, written_proxies } = process_node(
-			route.leaf,
-			outdir,
-			'RouteParams'
-		);
-
-		for (const file of written_proxies) to_delete.delete(file);
+		const { declarations: d, exports: e, written_proxies } = process_node(route.leaf, outdir, true);
 
-		exports.push(`export type Errors = ${errors};`);
+		exports.push(...e);
+		declarations.push(...d);
 
-		exports.push(`export type PageData = ${data};`);
-		if (load) {
-			exports.push(
-				`export type PageLoad<OutputData extends Record<string, any> | void = Record<string, any> | void> = ${load};`
-			);
-			exports.push('export type PageLoadEvent = Parameters<PageLoad>[0];');
-		}
-
-		exports.push(`export type PageServerData = ${server_data};`);
-		if (server_load) {
-			exports.push(
-				`export type PageServerLoad<OutputData extends Record<string, any> | void = Record<string, any> | void> = ${server_load};`
-			);
-			exports.push('export type PageServerLoadEvent = Parameters<PageServerLoad>[0];');
-		}
+		for (const file of written_proxies) to_delete.delete(file);
 
 		if (route.leaf.server) {
 			exports.push(`export type Action = Kit.Action<RouteParams>`);
@@ -188,47 +193,36 @@ function update_types(config, manifest_data, route) {
 	}
 
 	if (route.layout) {
-		// TODO collect children in create_manifest_data, instead of this inefficient O(n^2) algorithm
+		let all_pages_have_load = true;
 		const layout_params = new Set();
-		manifest_data.routes.forEach((other) => {
-			if (other.page && other.id.startsWith(route.id + '/')) {
-				// TODO this is O(n^2), see if we need to speed it up
-				for (const name of other.names) {
+		route.layout.child_pages?.forEach((page) => {
+			const leaf = routes.get(page);
+			if (leaf) {
+				for (const name of leaf.names) {
 					layout_params.add(name);
 				}
 			}
+			if (!page.server && !page.shared) {
+				all_pages_have_load = false;
+			}
 		});
 
-		if (layout_params.size > 0) {
-			const params = Array.from(layout_params).map((param) => `${param}?: string`);
-			declarations.push(`interface LayoutParams extends RouteParams { ${params.join('; ')} }`);
-		} else {
-			declarations.push(`interface LayoutParams extends RouteParams {}`);
-		}
-
-		const { data, server_data, load, server_load, written_proxies } = process_node(
-			route.layout,
-			outdir,
-			'LayoutParams'
+		declarations.push(
+			`type LayoutParams = RouteParams & { ${Array.from(layout_params).map(
+				(param) => `${param}?: string`
+			)} }`
 		);
 
-		for (const file of written_proxies) to_delete.delete(file);
+		const {
+			exports: e,
+			declarations: d,
+			written_proxies
+		} = process_node(route.layout, outdir, false, all_pages_have_load);
 
-		exports.push(`export type LayoutData = ${data};`);
-		if (load) {
-			exports.push(
-				`export type LayoutLoad<OutputData extends Record<string, any> | void = Record<string, any> | void> = ${load};`
-			);
-			exports.push('export type LayoutLoadEvent = Parameters<LayoutLoad>[0];');
-		}
+		exports.push(...e);
+		declarations.push(...d);
 
-		exports.push(`export type LayoutServerData = ${server_data};`);
-		if (server_load) {
-			exports.push(
-				`export type LayoutServerLoad<OutputData extends Record<string, any> | void = Record<string, any> | void> = ${server_load};`
-			);
-			exports.push('export type LayoutServerLoadEvent = Parameters<LayoutServerLoad>[0];');
-		}
+		for (const file of written_proxies) to_delete.delete(file);
 	}
 
 	if (route.endpoint) {
@@ -251,18 +245,24 @@ function update_types(config, manifest_data, route) {
 /**
  * @param {import('types').PageNode} node
  * @param {string} outdir
- * @param {string} params
+ * @param {boolean} is_page
+ * @param {boolean} [all_pages_have_load]
  */
-function process_node(node, outdir, params) {
-	let data;
-	let load;
-	let server_load;
-	let errors;
+function process_node(node, outdir, is_page, all_pages_have_load = true) {
+	const params = `${is_page ? 'Route' : 'Layout'}Params`;
+	const prefix = is_page ? 'Page' : 'Layout';
 
 	/** @type {string[]} */
 	let written_proxies = [];
+	/** @type {string[]} */
+	const declarations = [];
+	/** @type {string[]} */
+	const exports = [];
 
+	/** @type {string} */
 	let server_data;
+	/** @type {string} */
+	let data;
 
 	if (node.server) {
 		const content = fs.readFileSync(node.server, 'utf8');
@@ -274,33 +274,52 @@ function process_node(node, outdir, params) {
 		}
 
 		server_data = get_data_type(node.server, 'null', proxy);
-		server_load = `Kit.ServerLoad<${params}, ${get_parent_type(
-			node,
-			'LayoutServerData'
-		)}, OutputData>`;
 
-		if (proxy) {
-			const types = [];
-			for (const method of ['POST', 'PUT', 'PATCH']) {
-				if (proxy.exports.includes(method)) {
-					// If the file wasn't tweaked, we can use the return type of the original file.
-					// The advantage is that type updates are reflected without saving.
-					const from = proxy.modified
-						? `./proxy${replace_ext_with_js(basename)}`
-						: path_to_original(outdir, node.server);
-
-					types.push(`Kit.AwaitedErrors<typeof import('${from}').${method}>`);
+		const parent_type = `${prefix}ServerParentData`;
+
+		declarations.push(
+			`type ${parent_type} = EnsureParentData<${get_parent_type(node, 'LayoutServerData')}>;`
+		);
+
+		// +page.js load present -> server can return all-optional data
+		const output_data_shape =
+			node.shared || (!is_page && all_pages_have_load)
+				? `Partial<App.PageData> & Record<string, any> | void`
+				: `OutputDataShape<${parent_type}>`;
+		exports.push(
+			`export type ${prefix}ServerLoad<OutputData extends ${output_data_shape} = ${output_data_shape}> = Kit.ServerLoad<${params}, ${parent_type}, OutputData>;`
+		);
+
+		exports.push(`export type ${prefix}ServerLoadEvent = Parameters<${prefix}ServerLoad>[0];`);
+
+		if (is_page) {
+			let errors = 'unknown';
+			if (proxy) {
+				const types = [];
+				for (const method of ['POST', 'PUT', 'PATCH', 'DELETE']) {
+					if (proxy.exports.includes(method)) {
+						// If the file wasn't tweaked, we can use the return type of the original file.
+						// The advantage is that type updates are reflected without saving.
+						const from = proxy.modified
+							? `./proxy${replace_ext_with_js(basename)}`
+							: path_to_original(outdir, node.server);
+
+						types.push(`Kit.AwaitedErrors<typeof import('${from}').${method}>`);
+					}
 				}
+				errors = types.length ? types.join(' | ') : 'null';
 			}
-			errors = types.length ? types.join(' | ') : 'null';
-		} else {
-			errors = 'unknown';
+			exports.push(`export type Errors = ${errors};`);
 		}
 	} else {
 		server_data = 'null';
 	}
+	exports.push(`export type ${prefix}ServerData = ${server_data};`);
 
-	const parent_type = get_parent_type(node, 'LayoutData');
+	const parent_type = `${prefix}ParentData`;
+	declarations.push(
+		`type ${parent_type} = EnsureParentData<${get_parent_type(node, 'LayoutData')}>;`
+	);
 
 	if (node.shared) {
 		const content = fs.readFileSync(node.shared, 'utf8');
@@ -310,17 +329,28 @@ function process_node(node, outdir, params) {
 			written_proxies.push(`proxy${path.basename(node.shared)}`);
 		}
 
-		const type = get_data_type(node.shared, `${parent_type} & ${server_data}`, proxy);
+		const type = get_data_type(node.shared, `${parent_type} & ${prefix}ServerData`, proxy);
 
 		data = `Omit<${parent_type}, keyof ${type}> & ${type}`;
-		load = `Kit.Load<${params}, ${server_data}, ${parent_type}, OutputData>`;
+
+		const output_data_shape =
+			!is_page && all_pages_have_load
+				? `Partial<App.PageData> & Record<string, any> | void`
+				: `OutputDataShape<${parent_type}>`;
+		exports.push(
+			`export type ${prefix}Load<OutputData extends ${output_data_shape} = ${output_data_shape}> = Kit.Load<${params}, ${prefix}ServerData, ${parent_type}, OutputData>;`
+		);
+
+		exports.push(`export type ${prefix}LoadEvent = Parameters<${prefix}Load>[0];`);
 	} else if (server_data === 'null') {
 		data = parent_type;
 	} else {
-		data = `Omit<${parent_type}, keyof ${server_data}> & ${server_data}`;
+		data = `Omit<${parent_type}, keyof ${prefix}ServerData> & ${prefix}ServerData`;
 	}
 
-	return { data, server_data, load, server_load, errors, written_proxies };
+	exports.push(`export type ${prefix}Data = ${data};`);
+
+	return { declarations, exports, written_proxies };
 
 	/**
 	 * @param {string} file_path
@@ -364,7 +394,7 @@ function get_parent_type(node, type) {
 		parent = parent.parent;
 	}
 
-	let parent_str = parent_imports[0] || 'Record<never, never>';
+	let parent_str = parent_imports[0] || '{}';
 	for (let i = 1; i < parent_imports.length; i++) {
 		// Omit is necessary because a parent could have a property with the same key which would
 		// cause a type conflict. At runtime the child overwrites the parent property in this case,

package/src/core/sync/write_types/test/layout/+layout.js

@@ -0,0 +1,5 @@
+export function load() {
+	return {
+		shared: 'shared'
+	};
+}

package/src/core/sync/write_types/test/layout/+layout.server.js

@@ -0,0 +1,5 @@
+export function load() {
+	return {
+		server: 'server'
+	};
+}

package/src/core/sync/write_types/test/layout/+page.js

@@ -0,0 +1,5 @@
+export function load() {
+	return {
+		pageShared: 'pageShared'
+	};
+}

package/src/core/sync/write_types/test/layout/+page.server.js

@@ -0,0 +1,5 @@
+export function load() {
+	return {
+		pageServer: 'pageServer'
+	};
+}

package/src/core/sync/write_types/test/layout/_expected/$types.d.ts

@@ -0,0 +1,67 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = {};
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type PageServerParentData = EnsureParentData<LayoutServerData>;
+type PageParentData = EnsureParentData<LayoutData>;
+type LayoutParams = RouteParams & {};
+type LayoutServerParentData = EnsureParentData<{}>;
+type LayoutParentData = EnsureParentData<{}>;
+
+export type PageServerLoad<
+	OutputData extends (Partial<App.PageData> & Record<string, any>) | void =
+		| (Partial<App.PageData> & Record<string, any>)
+		| void
+> = Kit.ServerLoad<RouteParams, PageServerParentData, OutputData>;
+export type PageServerLoadEvent = Parameters<PageServerLoad>[0];
+export type Errors = null;
+export type PageServerData = Kit.AwaitedProperties<
+	Awaited<ReturnType<typeof import('../../../../../../../../+page.server.js').load>>
+>;
+export type PageLoad<
+	OutputData extends OutputDataShape<PageParentData> = OutputDataShape<PageParentData>
+> = Kit.Load<RouteParams, PageServerData, PageParentData, OutputData>;
+export type PageLoadEvent = Parameters<PageLoad>[0];
+export type PageData = Omit<
+	PageParentData,
+	keyof Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../+page.js').load>>
+	>
+> &
+	Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../+page.js').load>>
+	>;
+export type Action = Kit.Action<RouteParams>;
+export type LayoutServerLoad<
+	OutputData extends (Partial<App.PageData> & Record<string, any>) | void =
+		| (Partial<App.PageData> & Record<string, any>)
+		| void
+> = Kit.ServerLoad<LayoutParams, LayoutServerParentData, OutputData>;
+export type LayoutServerLoadEvent = Parameters<LayoutServerLoad>[0];
+export type LayoutServerData = Kit.AwaitedProperties<
+	Awaited<ReturnType<typeof import('../../../../../../../../+layout.server.js').load>>
+>;
+export type LayoutLoad<
+	OutputData extends (Partial<App.PageData> & Record<string, any>) | void =
+		| (Partial<App.PageData> & Record<string, any>)
+		| void
+> = Kit.Load<LayoutParams, LayoutServerData, LayoutParentData, OutputData>;
+export type LayoutLoadEvent = Parameters<LayoutLoad>[0];
+export type LayoutData = Omit<
+	LayoutParentData,
+	keyof Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../+layout.js').load>>
+	>
+> &
+	Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../+layout.js').load>>
+	>;

package/src/core/sync/write_types/test/layout-advanced/(main)/+layout.server.js

@@ -0,0 +1,5 @@
+export function load() {
+	return {
+		main: 'main'
+	};
+}

package/src/core/sync/write_types/test/layout-advanced/(main)/+page.js

@@ -0,0 +1,5 @@
+export function load() {
+	return {
+		page: 'page'
+	};
+}

package/src/core/sync/write_types/test/layout-advanced/(main)/sub/+page.js

@@ -0,0 +1,5 @@
+export function load() {
+	return {
+		sub: 'sub'
+	};
+}

package/src/core/sync/write_types/test/layout-advanced/+layout.js

@@ -0,0 +1,5 @@
+export function load() {
+	return {
+		root: 'root'
+	};
+}

package/src/core/sync/write_types/test/layout-advanced/_expected/$types.d.ts

@@ -0,0 +1,32 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = {};
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type LayoutParams = RouteParams & {};
+type LayoutParentData = EnsureParentData<{}>;
+
+export type LayoutServerData = null;
+export type LayoutLoad<
+	OutputData extends (Partial<App.PageData> & Record<string, any>) | void =
+		| (Partial<App.PageData> & Record<string, any>)
+		| void
+> = Kit.Load<LayoutParams, LayoutServerData, LayoutParentData, OutputData>;
+export type LayoutLoadEvent = Parameters<LayoutLoad>[0];
+export type LayoutData = Omit<
+	LayoutParentData,
+	keyof Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../+layout.js').load>>
+	>
+> &
+	Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../+layout.js').load>>
+	>;

package/src/core/sync/write_types/test/layout-advanced/_expected/(main)/$types.d.ts

@@ -0,0 +1,42 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = {};
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type PageParentData = EnsureParentData<import('../$types.js').LayoutData>;
+type LayoutParams = RouteParams & {};
+type LayoutServerParentData = EnsureParentData<import('../$types.js').LayoutServerData>;
+type LayoutParentData = EnsureParentData<import('../$types.js').LayoutData>;
+
+export type PageServerData = null;
+export type PageLoad<
+	OutputData extends OutputDataShape<PageParentData> = OutputDataShape<PageParentData>
+> = Kit.Load<RouteParams, PageServerData, PageParentData, OutputData>;
+export type PageLoadEvent = Parameters<PageLoad>[0];
+export type PageData = Omit<
+	PageParentData,
+	keyof Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../../(main)/+page.js').load>>
+	>
+> &
+	Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../../(main)/+page.js').load>>
+	>;
+export type LayoutServerLoad<
+	OutputData extends (Partial<App.PageData> & Record<string, any>) | void =
+		| (Partial<App.PageData> & Record<string, any>)
+		| void
+> = Kit.ServerLoad<LayoutParams, LayoutServerParentData, OutputData>;
+export type LayoutServerLoadEvent = Parameters<LayoutServerLoad>[0];
+export type LayoutServerData = Kit.AwaitedProperties<
+	Awaited<ReturnType<typeof import('../../../../../../../../../(main)/+layout.server.js').load>>
+>;
+export type LayoutData = Omit<LayoutParentData, keyof LayoutServerData> & LayoutServerData;

package/src/core/sync/write_types/test/layout-advanced/_expected/(main)/sub/$types.d.ts

@@ -0,0 +1,32 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = {};
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type PageParentData = EnsureParentData<
+	Omit<import('../../$types.js').LayoutData, keyof import('../$types.js').LayoutData> &
+		import('../$types.js').LayoutData
+>;
+
+export type PageServerData = null;
+export type PageLoad<
+	OutputData extends OutputDataShape<PageParentData> = OutputDataShape<PageParentData>
+> = Kit.Load<RouteParams, PageServerData, PageParentData, OutputData>;
+export type PageLoadEvent = Parameters<PageLoad>[0];
+export type PageData = Omit<
+	PageParentData,
+	keyof Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../../../(main)/sub/+page.js').load>>
+	>
+> &
+	Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../../../(main)/sub/+page.js').load>>
+	>;

package/src/core/sync/write_types/test/simple-page-server-and-shared/+page.js

@@ -0,0 +1,5 @@
+export function load() {
+	return {
+		shared: 'shared'
+	};
+}

package/src/core/sync/write_types/test/simple-page-server-and-shared/+page.server.js

@@ -0,0 +1,5 @@
+export function load() {
+	return {
+		server: 'server'
+	};
+}

package/src/core/sync/write_types/test/simple-page-server-and-shared/_expected/$types.d.ts

@@ -0,0 +1,44 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = {};
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type PageServerParentData = EnsureParentData<LayoutServerData>;
+type PageParentData = EnsureParentData<LayoutData>;
+type LayoutParams = RouteParams & {};
+type LayoutParentData = EnsureParentData<{}>;
+
+export type PageServerLoad<
+	OutputData extends (Partial<App.PageData> & Record<string, any>) | void =
+		| (Partial<App.PageData> & Record<string, any>)
+		| void
+> = Kit.ServerLoad<RouteParams, PageServerParentData, OutputData>;
+export type PageServerLoadEvent = Parameters<PageServerLoad>[0];
+export type Errors = null;
+export type PageServerData = Kit.AwaitedProperties<
+	Awaited<ReturnType<typeof import('../../../../../../../../+page.server.js').load>>
+>;
+export type PageLoad<
+	OutputData extends OutputDataShape<PageParentData> = OutputDataShape<PageParentData>
+> = Kit.Load<RouteParams, PageServerData, PageParentData, OutputData>;
+export type PageLoadEvent = Parameters<PageLoad>[0];
+export type PageData = Omit<
+	PageParentData,
+	keyof Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../+page.js').load>>
+	>
+> &
+	Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../+page.js').load>>
+	>;
+export type Action = Kit.Action<RouteParams>;
+export type LayoutServerData = null;
+export type LayoutData = LayoutParentData;

package/src/core/sync/write_types/test/simple-page-server-only/+page.server.js

@@ -0,0 +1,5 @@
+export function load() {
+	return {
+		foo: 'bar'
+	};
+}

package/src/core/sync/write_types/test/simple-page-server-only/_expected/$types.d.ts

@@ -0,0 +1,30 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = {};
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type PageServerParentData = EnsureParentData<LayoutServerData>;
+type PageParentData = EnsureParentData<LayoutData>;
+type LayoutParams = RouteParams & {};
+type LayoutParentData = EnsureParentData<{}>;
+
+export type PageServerLoad<
+	OutputData extends OutputDataShape<PageServerParentData> = OutputDataShape<PageServerParentData>
+> = Kit.ServerLoad<RouteParams, PageServerParentData, OutputData>;
+export type PageServerLoadEvent = Parameters<PageServerLoad>[0];
+export type Errors = null;
+export type PageServerData = Kit.AwaitedProperties<
+	Awaited<ReturnType<typeof import('../../../../../../../../+page.server.js').load>>
+>;
+export type PageData = Omit<PageParentData, keyof PageServerData> & PageServerData;
+export type Action = Kit.Action<RouteParams>;
+export type LayoutServerData = null;
+export type LayoutData = LayoutParentData;

package/src/core/sync/write_types/test/simple-page-shared-only/+page.js

@@ -0,0 +1,5 @@
+export function load() {
+	return {
+		shared: 'shared'
+	};
+}

package/src/core/sync/write_types/test/simple-page-shared-only/_expected/$types.d.ts

@@ -0,0 +1,33 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = {};
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type PageParentData = EnsureParentData<LayoutData>;
+type LayoutParams = RouteParams & {};
+type LayoutParentData = EnsureParentData<{}>;
+
+export type PageServerData = null;
+export type PageLoad<
+	OutputData extends OutputDataShape<PageParentData> = OutputDataShape<PageParentData>
+> = Kit.Load<RouteParams, PageServerData, PageParentData, OutputData>;
+export type PageLoadEvent = Parameters<PageLoad>[0];
+export type PageData = Omit<
+	PageParentData,
+	keyof Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../+page.js').load>>
+	>
+> &
+	Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../+page.js').load>>
+	>;
+export type LayoutServerData = null;
+export type LayoutData = LayoutParentData;

package/src/core/sync/write_types/test/slugs/+layout.js

@@ -0,0 +1 @@
+export function load() {}

package/src/core/sync/write_types/test/slugs/+layout.svelte

@@ -0,0 +1 @@
+export function load() {}

package/src/core/sync/write_types/test/slugs/[...rest]/+page.js

@@ -0,0 +1,3 @@
+export function load() {
+	return { rest: 'rest' };
+}

package/src/core/sync/write_types/test/slugs/[slug]/+page.js

@@ -0,0 +1,3 @@
+export function load() {
+	return { slug: 'slug' };
+}

package/src/core/sync/write_types/test/slugs/_expected/$types.d.ts

@@ -0,0 +1,32 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = {};
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type LayoutParams = RouteParams & { rest?: string; slug?: string };
+type LayoutParentData = EnsureParentData<{}>;
+
+export type LayoutServerData = null;
+export type LayoutLoad<
+	OutputData extends (Partial<App.PageData> & Record<string, any>) | void =
+		| (Partial<App.PageData> & Record<string, any>)
+		| void
+> = Kit.Load<LayoutParams, LayoutServerData, LayoutParentData, OutputData>;
+export type LayoutLoadEvent = Parameters<LayoutLoad>[0];
+export type LayoutData = Omit<
+	LayoutParentData,
+	keyof Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../+layout.js').load>>
+	>
+> &
+	Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../+layout.js').load>>
+	>;

package/src/core/sync/write_types/test/slugs/_expected/[...rest]/$types.d.ts

@@ -0,0 +1,29 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = { rest: string };
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type PageParentData = EnsureParentData<import('../$types.js').LayoutData>;
+
+export type PageServerData = null;
+export type PageLoad<
+	OutputData extends OutputDataShape<PageParentData> = OutputDataShape<PageParentData>
+> = Kit.Load<RouteParams, PageServerData, PageParentData, OutputData>;
+export type PageLoadEvent = Parameters<PageLoad>[0];
+export type PageData = Omit<
+	PageParentData,
+	keyof Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../../[...rest]/+page.js').load>>
+	>
+> &
+	Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../../[...rest]/+page.js').load>>
+	>;

package/src/core/sync/write_types/test/slugs/_expected/[slug]/$types.d.ts

@@ -0,0 +1,29 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = { slug: string };
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type PageParentData = EnsureParentData<import('../$types.js').LayoutData>;
+
+export type PageServerData = null;
+export type PageLoad<
+	OutputData extends OutputDataShape<PageParentData> = OutputDataShape<PageParentData>
+> = Kit.Load<RouteParams, PageServerData, PageParentData, OutputData>;
+export type PageLoadEvent = Parameters<PageLoad>[0];
+export type PageData = Omit<
+	PageParentData,
+	keyof Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../../[slug]/+page.js').load>>
+	>
+> &
+	Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../../[slug]/+page.js').load>>
+	>;

package/src/core/sync/write_types/test/slugs-layout-not-all-pages-have-load/+layout.js

@@ -0,0 +1 @@
+export function load() {}

package/src/core/sync/write_types/test/slugs-layout-not-all-pages-have-load/+layout.svelte

@@ -0,0 +1 @@
+export function load() {}

package/src/core/sync/write_types/test/slugs-layout-not-all-pages-have-load/_expected/$types.d.ts

@@ -0,0 +1,30 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = {};
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type LayoutParams = RouteParams & { rest?: string; slug?: string };
+type LayoutParentData = EnsureParentData<{}>;
+
+export type LayoutServerData = null;
+export type LayoutLoad<
+	OutputData extends OutputDataShape<LayoutParentData> = OutputDataShape<LayoutParentData>
+> = Kit.Load<LayoutParams, LayoutServerData, LayoutParentData, OutputData>;
+export type LayoutLoadEvent = Parameters<LayoutLoad>[0];
+export type LayoutData = Omit<
+	LayoutParentData,
+	keyof Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../+layout.js').load>>
+	>
+> &
+	Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../+layout.js').load>>
+	>;

package/src/core/sync/write_types/test/slugs-layout-not-all-pages-have-load/_expected/nested/$types.d.ts

@@ -0,0 +1,32 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = {};
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type LayoutParams = RouteParams & { rest?: string };
+type LayoutParentData = EnsureParentData<import('../$types.js').LayoutData>;
+
+export type LayoutServerData = null;
+export type LayoutLoad<
+	OutputData extends (Partial<App.PageData> & Record<string, any>) | void =
+		| (Partial<App.PageData> & Record<string, any>)
+		| void
+> = Kit.Load<LayoutParams, LayoutServerData, LayoutParentData, OutputData>;
+export type LayoutLoadEvent = Parameters<LayoutLoad>[0];
+export type LayoutData = Omit<
+	LayoutParentData,
+	keyof Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../../nested/+layout.js').load>>
+	>
+> &
+	Kit.AwaitedProperties<
+		Awaited<ReturnType<typeof import('../../../../../../../../../nested/+layout.js').load>>
+	>;

package/src/core/sync/write_types/test/slugs-layout-not-all-pages-have-load/_expected/nested/[...rest]/$types.d.ts

@@ -0,0 +1,36 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = { rest: string };
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type PageParentData = EnsureParentData<
+	Omit<import('../../$types.js').LayoutData, keyof import('../$types.js').LayoutData> &
+		import('../$types.js').LayoutData
+>;
+
+export type PageServerData = null;
+export type PageLoad<
+	OutputData extends OutputDataShape<PageParentData> = OutputDataShape<PageParentData>
+> = Kit.Load<RouteParams, PageServerData, PageParentData, OutputData>;
+export type PageLoadEvent = Parameters<PageLoad>[0];
+export type PageData = Omit<
+	PageParentData,
+	keyof Kit.AwaitedProperties<
+		Awaited<
+			ReturnType<typeof import('../../../../../../../../../../nested/[...rest]/+page.js').load>
+		>
+	>
+> &
+	Kit.AwaitedProperties<
+		Awaited<
+			ReturnType<typeof import('../../../../../../../../../../nested/[...rest]/+page.js').load>
+		>
+	>;

package/src/core/sync/write_types/test/slugs-layout-not-all-pages-have-load/_expected/nested/[slug]/$types.d.ts

@@ -0,0 +1,17 @@
+import type * as Kit from '@sveltejs/kit';
+
+type RouteParams = { slug: string };
+type MaybeWithVoid<T> = {} extends T ? T | void : T;
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+type OutputDataShape<T> = MaybeWithVoid<
+	Omit<App.PageData, RequiredKeys<T>> &
+		Partial<Pick<App.PageData, keyof T & keyof App.PageData>> &
+		Record<string, any>
+>;
+type EnsureParentData<T> = NonNullable<T> extends never ? {} : T;
+type PageParentData = EnsureParentData<import('../../$types.js').LayoutData>;
+
+export type PageServerData = null;
+export type PageData = PageParentData;

package/src/core/sync/write_types/test/slugs-layout-not-all-pages-have-load/nested/+layout.js

@@ -0,0 +1 @@
+export function load() {}

package/src/core/sync/write_types/test/slugs-layout-not-all-pages-have-load/nested/+layout.svelte

@@ -0,0 +1 @@
+export function load() {}

package/src/core/sync/write_types/test/slugs-layout-not-all-pages-have-load/nested/[...rest]/+page.js

@@ -0,0 +1,3 @@
+export function load() {
+	return { rest: 'rest' };
+}

package/types/ambient.d.ts

@@ -7,6 +7,8 @@
  * declare namespace App {
  * 	interface Locals {}
  *
+ * 	interface PageData {}
+ *
  * 	interface Platform {}
  *
  * 	interface PrivateEnv {}
@@ -47,6 +49,13 @@ declare namespace App {
 	 */
 	export interface Locals {}
 
+	/**
+	 * Defines the common shape of the [$page.data store](https://kit.svelte.dev/docs/modules#$app-stores-page) - that is, the data that is shared between all pages.
+	 * The `Load` and `ServerLoad` functions in `./$types` will be narrowed accordingly.
+	 * Use optional properties for data that is only present on specific pages. Do not add an index signature (`[key: string]: any`).
+	 */
+	export interface PageData {}
+
 	/**
 	 * If your adapter provides [platform-specific context](https://kit.svelte.dev/docs/adapters#supported-environments-platform-specific-context) via `event.platform`, you can specify it here.
 	 */

package/types/index.d.ts

@@ -195,17 +195,17 @@ export interface HandleError {
  */
 export interface Load<
 	Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,
-	InputData extends Record<string, any> | null = Record<string, any> | null,
-	ParentData extends Record<string, any> = Record<string, any>,
-	OutputData extends Record<string, any> | void = Record<string, any> | void
+	InputData extends Record<string, unknown> | null = Record<string, any> | null,
+	ParentData extends Record<string, unknown> = Record<string, any>,
+	OutputData extends Record<string, unknown> | void = Record<string, any> | void
 > {
 	(event: LoadEvent<Params, InputData, ParentData>): MaybePromise<OutputData>;
 }
 
 export interface LoadEvent<
 	Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,
-	Data extends Record<string, any> | null = Record<string, any> | null,
-	ParentData extends Record<string, any> = Record<string, any>
+	Data extends Record<string, unknown> | null = Record<string, any> | null,
+	ParentData extends Record<string, unknown> = Record<string, any>
 > {
 	fetch(info: RequestInfo, init?: RequestInit): Promise<Response>;
 	params: Params;
@@ -228,7 +228,7 @@ export interface Page<Params extends Record<string, string> = Record<string, str
 	routeId: string | null;
 	status: number;
 	error: HttpError | Error | null;
-	data: Record<string, any>;
+	data: App.PageData & Record<string, any>;
 }
 
 export interface ParamMatcher {
@@ -253,7 +253,9 @@ export interface RequestEvent<
  *
  * It receives `Params` as the first generic argument, which you can skip by using [generated types](/docs/types#generated-types) instead.
  */
-export interface RequestHandler<Params extends Record<string, string> = Record<string, string>> {
+export interface RequestHandler<
+	Params extends Partial<Record<string, string>> = Partial<Record<string, string>>
+> {
 	(event: RequestEvent<Params>): MaybePromise<Response>;
 }
 

package/types/internal.d.ts

@@ -122,6 +122,10 @@ export interface PageNode {
 	server?: string;
 	parent_id?: string;
 	parent?: PageNode;
+	/**
+	 * Filled with the pages that reference this layout (if this is a layout)
+	 */
+	child_pages?: PageNode[];
 }
 
 export type PayloadScriptAttributes =