@sveltejs/kit 1.0.0-next.403 → 1.0.0-next.407

package/types/index.d.ts

@@ -6,8 +6,8 @@ import './ambient.js';
 import { CompileOptions } from 'svelte/types/compiler/interfaces';
 import {
 	AdapterEntry,
-	BodyValidator,
 	CspDirectives,
+	JSONObject,
 	JSONValue,
 	Logger,
 	MaybePromise,
@@ -19,12 +19,29 @@ import {
 	TrailingSlash
 } from './private.js';
 import { SSRNodeLoader, SSRRoute, ValidatedConfig } from './internal.js';
+import { HttpError, Redirect } from '../src/index/private.js';
 
 export interface Adapter {
 	name: string;
 	adapt(builder: Builder): MaybePromise<void>;
 }
 
+export type AwaitedProperties<input extends Record<string, any> | void> = input extends void
+	? undefined // needs to be undefined, because void will break intellisense
+	: input extends Record<string, any>
+	? {
+			[key in keyof input]: Awaited<input[key]>;
+	  }
+	: {} extends input // handles the any case
+	? input
+	: unknown;
+
+export type AwaitedErrors<T extends (...args: any) => any> = Awaited<ReturnType<T>> extends {
+	errors?: any;
+}
+	? Awaited<ReturnType<T>>['errors']
+	: undefined;
+
 export interface Builder {
 	log: Logger;
 	rimraf(dir: string): void;
@@ -80,6 +97,11 @@ export interface Builder {
 			replace?: Record<string, string>;
 		}
 	): string[];
+
+	/**
+	 * @param {string} directory Path to the directory containing the files to be compressed
+	 */
+	compress(directory: string): void;
 }
 
 export interface Config {
@@ -140,7 +162,6 @@ export interface KitConfig {
 		onError?: PrerenderOnErrorValue;
 		origin?: string;
 	};
-	routes?: (filepath: string) => boolean;
 	serviceWorker?: {
 		register?: boolean;
 		files?: (filepath: string) => boolean;
@@ -172,46 +193,32 @@ export interface HandleError {
 }
 
 /**
- * The `(event: LoadEvent) => LoadOutput` `load` function exported from `<script context="module">` in a page or layout.
- *
- * Note that you can use [generated types](/docs/types#generated-types) instead of manually specifying the Params generic argument.
+ * The generic form of `PageLoad` and `LayoutLoad`. You should import those from `./$types` (see [generated types](https://kit.svelte.dev/docs/types#generated-types))
+ * rather than using `Load` directly.
  */
 export interface Load<
 	Params extends Record<string, string> = Record<string, string>,
-	InputProps extends Record<string, any> = Record<string, any>,
-	OutputProps extends Record<string, any> = InputProps
+	InputData extends JSONObject | null = JSONObject | null,
+	ParentData extends Record<string, any> | null = Record<string, any> | null,
+	OutputData extends Record<string, any> = Record<string, any>
 > {
-	(event: LoadEvent<Params, InputProps>): MaybePromise<LoadOutput<OutputProps> | void>;
+	(event: LoadEvent<Params, InputData, ParentData>): MaybePromise<OutputData | void>;
 }
 
 export interface LoadEvent<
 	Params extends Record<string, string> = Record<string, string>,
-	Props extends Record<string, any> = Record<string, any>
+	Data extends JSONObject | null = JSONObject | null,
+	ParentData extends Record<string, any> | null = Record<string, any> | null
 > {
 	fetch(info: RequestInfo, init?: RequestInit): Promise<Response>;
 	params: Params;
-	props: Props;
+	data: Data;
 	routeId: string | null;
 	session: App.Session;
-	stuff: Partial<App.Stuff>;
+	setHeaders: (headers: ResponseHeaders) => void;
 	url: URL;
-	status: number | null;
-	error: Error | null;
-}
-
-export interface LoadOutput<Props extends Record<string, any> = Record<string, any>> {
-	status?: number;
-	error?: string | Error;
-	redirect?: string;
-	props?: Props;
-	stuff?: Partial<App.Stuff>;
-	cache?: LoadOutputCache;
-	dependencies?: string[];
-}
-
-export interface LoadOutputCache {
-	maxage: number;
-	private?: boolean;
+	parent: () => Promise<ParentData>;
+	depends: (...deps: string[]) => void;
 }
 
 export interface Navigation {
@@ -223,9 +230,9 @@ export interface Page<Params extends Record<string, string> = Record<string, str
 	url: URL;
 	params: Params;
 	routeId: string | null;
-	stuff: App.Stuff;
 	status: number;
-	error: Error | null;
+	error: HttpError | Error | null;
+	data: Record<string, any>;
 }
 
 export interface ParamMatcher {
@@ -239,27 +246,17 @@ export interface RequestEvent<Params extends Record<string, string> = Record<str
 	platform: Readonly<App.Platform>;
 	request: Request;
 	routeId: string | null;
+	setHeaders: (headers: ResponseHeaders) => void;
 	url: URL;
 }
 
 /**
- * A `(event: RequestEvent) => RequestHandlerOutput` function exported from an endpoint 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.
- *
- * The next generic argument `Output` is used to validate the returned `body` from your functions by passing it through `BodyValidator`, which will make sure the variable in the `body` matches what with you assign here. It defaults to `ResponseBody`, which will error when `body` receives a [custom object type](https://www.typescriptlang.org/docs/handbook/2/objects.html).
  */
-export interface RequestHandler<
-	Params extends Record<string, string> = Record<string, string>,
-	Output = ResponseBody
-> {
-	(event: RequestEvent<Params>): MaybePromise<RequestHandlerOutput<Output>>;
-}
-
-export interface RequestHandlerOutput<Output = ResponseBody> {
-	status?: number;
-	headers?: Headers | Partial<ResponseHeaders>;
-	body?: Output extends ResponseBody ? Output : BodyValidator<Output>;
+export interface RequestHandler<Params extends Record<string, string> = Record<string, string>> {
+	(event: RequestEvent<Params>): MaybePromise<Response>;
 }
 
 export interface ResolveOptions {
@@ -296,3 +293,53 @@ export interface SSRManifest {
 		matchers: () => Promise<Record<string, ParamMatcher>>;
 	};
 }
+
+/**
+ * The generic form of `PageServerLoad` and `LayoutServerLoad`. You should import those from `./$types` (see [generated types](https://kit.svelte.dev/docs/types#generated-types))
+ * rather than using `ServerLoad` directly.
+ */
+export interface ServerLoad<
+	Params extends Record<string, string> = Record<string, string>,
+	ParentData extends JSONObject | null = JSONObject | null,
+	OutputData extends JSONObject | void = JSONObject | void
+> {
+	(event: ServerLoadEvent<Params, ParentData>): MaybePromise<OutputData | void>;
+}
+
+export interface ServerLoadEvent<
+	Params extends Record<string, string> = Record<string, string>,
+	ParentData extends JSONObject | null = JSONObject | null
+> extends RequestEvent<Params> {
+	parent: () => Promise<ParentData>;
+}
+
+export interface Action<Params extends Record<string, string> = Record<string, string>> {
+	(event: RequestEvent<Params>): MaybePromise<
+		| { status?: number; errors: Record<string, string>; location?: never }
+		| { status?: never; errors?: never; location: string }
+		| void
+	>;
+}
+
+// TODO figure out how to just re-export from '../src/index/index.js' without
+// breaking the site
+
+/**
+ * Creates an `HttpError` object with an HTTP status code and an optional message.
+ * This object, if thrown during request handling, will cause SvelteKit to
+ * return an error response without invoking `handleError`
+ * @param {number} status
+ * @param {string | undefined} [message]
+ */
+export function error(status: number, message?: string | undefined): HttpError;
+
+/**
+ * Creates a `Redirect` object. If thrown during request handling, SvelteKit will
+ * return a redirect response.
+ */
+export function redirect(status: number, location: string): Redirect;
+
+/**
+ * Generates a JSON `Response` object from the supplied data.
+ */
+export function json(data: any, init?: ResponseInit): Response;

package/types/internal.d.ts

@@ -1,7 +1,10 @@
 import { OutputAsset, OutputChunk } from 'rollup';
+import { SvelteComponent } from 'svelte/internal';
 import {
+	Action,
 	Config,
 	ExternalFetch,
+	ServerLoad,
 	GetSession,
 	Handle,
 	HandleError,
@@ -14,14 +17,7 @@ import {
 	ServerInitOptions,
 	SSRManifest
 } from './index.js';
-import {
-	HttpMethod,
-	JSONObject,
-	MaybePromise,
-	RequestOptions,
-	ResponseHeaders,
-	TrailingSlash
-} from './private.js';
+import { HttpMethod, MaybePromise, RequestOptions, TrailingSlash } from './private.js';
 
 export interface ServerModule {
 	Server: typeof InternalServer;
@@ -64,16 +60,25 @@ export interface BuildData {
 	};
 }
 
-export type CSRComponent = any; // TODO
+export interface CSRPageNode {
+	component: typeof SvelteComponent;
+	shared: {
+		load: Load;
+		hydrate: boolean;
+		router: boolean;
+	};
+	server: boolean;
+}
 
-export type CSRComponentLoader = () => Promise<CSRComponent>;
+export type CSRPageNodeLoader = () => Promise<CSRPageNode>;
 
 export type CSRRoute = {
 	id: string;
 	exec: (path: string) => undefined | Record<string, string>;
-	a: CSRComponentLoader[];
-	b: CSRComponentLoader[];
-	has_shadow: boolean;
+	errors: CSRPageNodeLoader[];
+	layouts: CSRPageNodeLoader[];
+	leaf: CSRPageNodeLoader;
+	uses_server_data: boolean;
 };
 
 export interface EndpointData {
@@ -109,7 +114,7 @@ export class InternalServer extends Server {
 
 export interface ManifestData {
 	assets: Asset[];
-	components: string[];
+	nodes: PageNode[];
 	routes: RouteData[];
 	matchers: Record<string, string>;
 }
@@ -119,34 +124,24 @@ export interface MethodOverride {
 	allowed: string[];
 }
 
-export type NormalizedLoadOutput = {
-	status?: number;
-	error?: Error;
-	redirect?: string;
-	props?: Record<string, any> | Promise<Record<string, any>>;
-	stuff?: Record<string, any>;
-	cache?: NormalizedLoadOutputCache;
-	dependencies?: string[];
-};
-
-export interface NormalizedLoadOutputCache {
-	maxage: number;
-	private?: boolean;
+export interface PageNode {
+	component?: string; // TODO supply default component if it's missing (bit of an edge case)
+	shared?: string;
+	server?: string;
 }
 
 export interface PageData {
 	type: 'page';
 	id: string;
-	shadow: string | null;
 	pattern: RegExp;
-	path: string;
-	a: Array<string | undefined>;
-	b: Array<string | undefined>;
+	errors: Array<PageNode | undefined>;
+	layouts: Array<PageNode | undefined>;
+	leaf: PageNode;
 }
 
 export type PayloadScriptAttributes =
 	| { type: 'data'; url: string; body?: string }
-	| { type: 'props' };
+	| { type: 'server_data' };
 
 export interface PrerenderDependency {
 	response: Response;
@@ -154,6 +149,7 @@ export interface PrerenderDependency {
 }
 
 export interface PrerenderOptions {
+	cache?: string; // including this here is a bit of a hack, but it makes it easy to add <meta http-equiv>
 	fallback?: boolean;
 	dependencies: Map<string, PrerenderDependency>;
 }
@@ -174,29 +170,7 @@ export interface Respond {
 
 export type RouteData = PageData | EndpointData;
 
-export interface ShadowEndpointOutput<Output extends JSONObject = JSONObject> {
-	status?: number;
-	headers?: Partial<ResponseHeaders>;
-	body?: Output;
-}
-
-export interface ShadowRequestHandler<Output extends JSONObject = JSONObject> {
-	(event: RequestEvent): MaybePromise<ShadowEndpointOutput<Output>>;
-}
-
-export interface ShadowData {
-	status?: number;
-	error?: Error;
-	redirect?: string;
-	cookies?: string[];
-	body?: JSONObject;
-}
-
 export interface SSRComponent {
-	router?: boolean;
-	hydrate?: boolean;
-	prerender?: boolean;
-	load: Load;
 	default: {
 		render(props: Record<string, any>): {
 			html: string;
@@ -217,13 +191,11 @@ export interface SSREndpoint {
 	pattern: RegExp;
 	names: string[];
 	types: string[];
-	load(): Promise<{
-		[method: string]: RequestHandler;
-	}>;
+	load(): Promise<Partial<Record<HttpMethod, RequestHandler>>>;
 }
 
 export interface SSRNode {
-	module: SSRComponent;
+	component: SSRComponent;
 	/** index into the `components` array in client-manifest.js */
 	index: number;
 	/** client-side module URL for this component */
@@ -234,6 +206,23 @@ export interface SSRNode {
 	stylesheets: string[];
 	/** inlined styles */
 	inline_styles?: () => MaybePromise<Record<string, string>>;
+
+	shared: {
+		load?: Load;
+		hydrate?: boolean;
+		prerender?: boolean;
+		router?: boolean;
+		ssr?: boolean;
+	};
+
+	server: {
+		load?: ServerLoad;
+		HEAD?: ServerLoad;
+		POST?: Action;
+		PATCH?: Action;
+		PUT?: Action;
+		DELETE?: Action;
+	};
 }
 
 export type SSRNodeLoader = () => Promise<SSRNode>;
@@ -282,20 +271,9 @@ export interface SSRPage {
 	pattern: RegExp;
 	names: string[];
 	types: string[];
-	shadow:
-		| null
-		| (() => Promise<{
-				[method: string]: ShadowRequestHandler;
-		  }>);
-	/**
-	 * plan a is to render 1 or more layout components followed by a leaf component.
-	 */
-	a: Array<number | undefined>;
-	/**
-	 * plan b — if one of them components fails in `load` we backtrack until we find
-	 * the nearest error component.
-	 */
-	b: Array<number | undefined>;
+	errors: Array<number | undefined>;
+	layouts: Array<number | undefined>;
+	leaf: number;
 }
 
 export interface SSRErrorPage {

package/types/private.d.ts

@@ -26,6 +26,7 @@ export interface AdapterEntry {
 	}) => MaybePromise<void>;
 }
 
+// TODO is this still used?
 export type BodyValidator<T> = {
 	[P in keyof T]: T[P] extends { [k: string]: unknown }
 		? BodyValidator<T[P]> // recurse when T[P] is an object
@@ -212,7 +213,7 @@ export interface RequestOptions {
 }
 
 /** `string[]` is only for set-cookie, everything else must be type of `string` */
-export type ResponseHeaders = Record<string, string | number | string[]>;
+export type ResponseHeaders = Record<string, string | number | string[] | null>;
 
 export interface RouteDefinition {
 	id: string;

package/assets/app/navigation.js

@@ -1,24 +0,0 @@
-import { client } from '../client/singletons.js';
-
-/**
- * @param {string} name
- */
-function guard(name) {
-	return () => {
-		throw new Error(`Cannot call ${name}(...) on the server`);
-	};
-}
-
-const ssr = import.meta.env.SSR;
-
-const disableScrollHandling = ssr
-	? guard('disableScrollHandling')
-	: client.disable_scroll_handling;
-const goto = ssr ? guard('goto') : client.goto;
-const invalidate = ssr ? guard('invalidate') : client.invalidate;
-const prefetch = ssr ? guard('prefetch') : client.prefetch;
-const prefetchRoutes = ssr ? guard('prefetchRoutes') : client.prefetch_routes;
-const beforeNavigate = ssr ? () => {} : client.before_navigate;
-const afterNavigate = ssr ? () => {} : client.after_navigate;
-
-export { afterNavigate, beforeNavigate, disableScrollHandling, goto, invalidate, prefetch, prefetchRoutes };

package/assets/app/paths.js

@@ -1 +0,0 @@
-export { assets, base } from '../paths.js';

package/assets/components/error.svelte

@@ -1,29 +0,0 @@
-<script context="module">
-	/** @type {import('@sveltejs/kit').Load} */
-	export function load({ error, status }) {
-		return {
-			props: { error, status }
-		};
-	}
-</script>
-
-<script>
-	/** @type {number} */
-	export let status;
-
-	/** @type {Error & {frame?: string} & {loc?: object}} */
-	export let error;
-</script>
-
-<h1>{status}</h1>
-
-<pre>{error.message}</pre>
-
-<!-- TODO figure out what to do with frames/stacktraces in prod -->
-<!-- frame is populated by Svelte in its CompileError and is a Rollup/Vite convention -->
-{#if error.frame}
-	<pre>{error.frame}</pre>
-{/if}
-{#if error.stack}
-	<pre>{error.stack}</pre>
-{/if}

package/assets/env.js

@@ -1,8 +0,0 @@
-let prerendering = false;
-
-/** @param {boolean} value */
-function set_prerendering(value) {
-	prerendering = value;
-}
-
-export { prerendering, set_prerendering };