@sveltejs/kit 1.0.0-next.402 → 1.0.0-next.406

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 };