@sveltejs/kit 1.0.0-next.277 → 1.0.0-next.280

package/types/internal.d.ts

@@ -1,24 +1,45 @@
 import { OutputAsset, OutputChunk } from 'rollup';
-import { ValidatedConfig } from './config';
-import { InternalApp, SSRManifest } from './app';
-import { Fallthrough, RequestHandler, ShadowRequestHandler } from './endpoint';
-import { Either } from './helper';
-import { ExternalFetch, GetSession, Handle, HandleError, RequestEvent } from './hooks';
-import { Load } from './page';
+import {
+	SSRManifest,
+	ValidatedConfig,
+	RequestHandler,
+	Load,
+	ExternalFetch,
+	GetSession,
+	Handle,
+	HandleError,
+	RequestEvent,
+	RequestOptions,
+	PrerenderErrorHandler,
+	Server
+} from './index';
 
-export interface PrerenderDependency {
-	response: Response;
-	body: null | string | Uint8Array;
-}
+export interface AdapterEntry {
+	/**
+	 * A string that uniquely identifies an HTTP service (e.g. serverless function) and is used for deduplication.
+	 * For example, `/foo/a-[b]` and `/foo/[c]` are different routes, but would both
+	 * be represented in a Netlify _redirects file as `/foo/:param`, so they share an ID
+	 */
+	id: string;
 
-export interface PrerenderOptions {
-	fallback?: string;
-	all: boolean;
-	dependencies: Map<string, PrerenderDependency>;
+	/**
+	 * A function that compares the candidate route with the current route to determine
+	 * if it should be treated as a fallback for the current route. For example, `/foo/[c]`
+	 * is a fallback for `/foo/a-[b]`, and `/[...catchall]` is a fallback for all routes
+	 */
+	filter: (route: RouteDefinition) => boolean;
+
+	/**
+	 * A function that is invoked once the entry has been created. This is where you
+	 * should write the function to the filesystem and generate redirect manifests.
+	 */
+	complete: (entry: {
+		generateManifest: (opts: { relativePath: string; format?: 'esm' | 'cjs' }) => string;
+	}) => void;
 }
 
-export interface AppModule {
-	App: typeof InternalApp;
+export interface ServerModule {
+	Server: typeof InternalServer;
 
 	override(options: {
 		paths: {
@@ -31,6 +52,84 @@ export interface AppModule {
 	}): void;
 }
 
+export interface Asset {
+	file: string;
+	size: number;
+	type: string | null;
+}
+
+export type Body = JSONValue | Uint8Array | ReadableStream | import('stream').Readable;
+
+export interface BuildData {
+	app_dir: string;
+	manifest_data: ManifestData;
+	service_worker: string | null;
+	client: {
+		assets: OutputAsset[];
+		chunks: OutputChunk[];
+		entry: {
+			file: string;
+			js: string[];
+			css: string[];
+		};
+		vite_manifest: import('vite').Manifest;
+	};
+	server: {
+		chunks: OutputChunk[];
+		methods: Record<string, HttpMethod[]>;
+		vite_manifest: import('vite').Manifest;
+	};
+	static: string[];
+	entries: string[];
+}
+
+export type CSRComponent = any; // TODO
+
+export type CSRComponentLoader = () => Promise<CSRComponent>;
+
+export type CSRRoute = [RegExp, CSRComponentLoader[], CSRComponentLoader[], GetParams?, HasShadow?];
+
+export type Either<T, U> = Only<T, U> | Only<U, T>;
+
+export interface EndpointData {
+	type: 'endpoint';
+	key: string;
+	segments: RouteSegment[];
+	pattern: RegExp;
+	params: string[];
+	file: string;
+}
+
+export interface Fallthrough {
+	fallthrough: true;
+}
+
+export type GetParams = (match: RegExpExecArray) => Record<string, string>;
+
+type HasShadow = 1;
+
+export interface Hooks {
+	externalFetch: ExternalFetch;
+	getSession: GetSession;
+	handle: Handle;
+	handleError: HandleError;
+}
+
+export type HttpMethod = 'get' | 'head' | 'post' | 'put' | 'delete' | 'patch';
+
+export class InternalServer extends Server {
+	respond(
+		request: Request,
+		options?: RequestOptions & {
+			prerender?: PrerenderOptions;
+		}
+	): Promise<Response>;
+}
+
+export type JSONObject = { [key: string]: JSONValue };
+
+export type JSONValue = string | number | boolean | null | ToJSON | JSONValue[] | JSONObject;
+
 export interface Logger {
 	(msg: string): void;
 	success(msg: string): void;
@@ -40,6 +139,117 @@ export interface Logger {
 	info(msg: string): void;
 }
 
+export interface ManifestData {
+	assets: Asset[];
+	layout: string;
+	error: string;
+	components: string[];
+	routes: RouteData[];
+}
+
+export type MaybePromise<T> = T | Promise<T>;
+
+export interface MethodOverride {
+	parameter: string;
+	allowed: string[];
+}
+
+export type NormalizedLoadOutput = Either<
+	{
+		status: number;
+		error?: Error;
+		redirect?: string;
+		props?: Record<string, any> | Promise<Record<string, any>>;
+		stuff?: Record<string, any>;
+		maxage?: number;
+	},
+	Fallthrough
+>;
+
+type Only<T, U> = { [P in keyof T]: T[P] } & { [P in Exclude<keyof U, keyof T>]?: never };
+
+export interface PageData {
+	type: 'page';
+	key: string;
+	shadow: string | null;
+	segments: RouteSegment[];
+	pattern: RegExp;
+	params: string[];
+	path: string;
+	a: string[];
+	b: string[];
+}
+
+export interface PrerenderDependency {
+	response: Response;
+	body: null | string | Uint8Array;
+}
+
+export type PrerenderOnErrorValue = 'fail' | 'continue' | PrerenderErrorHandler;
+
+export interface PrerenderOptions {
+	fallback?: string;
+	all: boolean;
+	dependencies: Map<string, PrerenderDependency>;
+}
+
+export type RecursiveRequired<T> = {
+	// Recursive implementation of TypeScript's Required utility type.
+	// Will recursively continue until it reaches primitive or union
+	// with a Function in it, except those commented below
+	[K in keyof T]-?: Extract<T[K], Function> extends never // If it does not have a Function type
+		? RecursiveRequired<T[K]> // recursively continue through.
+		: K extends 'vite' // If it reaches the 'vite' key
+		? Extract<T[K], Function> // only take the Function type.
+		: T[K]; // Use the exact type for everything else
+};
+
+export interface RequiredResolveOptions {
+	ssr: boolean;
+	transformPage: ({ html }: { html: string }) => string;
+}
+
+export interface Respond {
+	(request: Request, options: SSROptions, state?: SSRState): Promise<Response>;
+}
+
+/** `string[]` is only for set-cookie, everything else must be type of `string` */
+export type ResponseHeaders = Record<string, string | number | string[]>;
+
+export type RouteData = PageData | EndpointData;
+
+export interface RouteDefinition {
+	type: 'page' | 'endpoint';
+	pattern: RegExp;
+	segments: RouteSegment[];
+	methods: HttpMethod[];
+}
+
+export interface RouteSegment {
+	content: string;
+	dynamic: boolean;
+	rest: boolean;
+}
+
+export interface ShadowEndpointOutput<Output extends JSONObject = JSONObject> {
+	status?: number;
+	headers?: Partial<ResponseHeaders>;
+	body?: Output;
+}
+
+export interface ShadowRequestHandler<Output extends JSONObject = JSONObject> {
+	(event: RequestEvent): MaybePromise<Either<ShadowEndpointOutput<Output>, Fallthrough>>;
+}
+
+export interface ShadowData {
+	fallthrough?: boolean;
+	status?: number;
+	error?: Error;
+	redirect?: string;
+	cookies?: string[];
+	body?: JSONObject;
+}
+
 export interface SSRComponent {
 	router?: boolean;
 	hydrate?: boolean;
@@ -59,37 +269,6 @@ export interface SSRComponent {
 
 export type SSRComponentLoader = () => Promise<SSRComponent>;
 
-export type CSRComponent = any; // TODO
-
-export type CSRComponentLoader = () => Promise<CSRComponent>;
-
-export interface SSRPagePart {
-	id: string;
-	load: SSRComponentLoader;
-}
-
-export type GetParams = (match: RegExpExecArray) => Record<string, string>;
-
-export interface SSRPage {
-	type: 'page';
-	pattern: RegExp;
-	params: GetParams;
-	shadow:
-		| null
-		| (() => Promise<{
-				[method: string]: ShadowRequestHandler;
-		  }>);
-	/**
-	 * plan a is to render 1 or more layout components followed by a leaf component.
-	 */
-	a: number[];
-	/**
-	 * plan b — if one of them components fails in `load` we backtrack until we find
-	 * the nearest error component.
-	 */
-	b: number[];
-}
-
 export interface SSREndpoint {
 	type: 'endpoint';
 	pattern: RegExp;
@@ -99,20 +278,6 @@ export interface SSREndpoint {
 	}>;
 }
 
-export type SSRRoute = SSREndpoint | SSRPage;
-
-type HasShadow = 1;
-export type CSRRoute = [RegExp, CSRComponentLoader[], CSRComponentLoader[], GetParams?, HasShadow?];
-
-export type SSRNodeLoader = () => Promise<SSRNode>;
-
-export interface Hooks {
-	externalFetch: ExternalFetch;
-	getSession: GetSession;
-	handle: Handle;
-	handleError: HandleError;
-}
-
 export interface SSRNode {
 	module: SSRComponent;
 	/** client-side module URL for this component */
@@ -125,6 +290,8 @@ export interface SSRNode {
 	styles?: Record<string, string>;
 }
 
+export type SSRNodeLoader = () => Promise<SSRNode>;
+
 export interface SSROptions {
 	amp: boolean;
 	csp: ValidatedConfig['kit']['csp'];
@@ -161,100 +328,45 @@ export interface SSROptions {
 	trailing_slash: TrailingSlash;
 }
 
-export interface SSRState {
-	fetched?: string;
-	initiator?: SSRPage | null;
-	platform?: any;
-	prerender?: PrerenderOptions;
-	fallback?: string;
-}
-
-export interface Asset {
-	file: string;
-	size: number;
-	type: string | null;
-}
-
-export interface RouteSegment {
-	content: string;
-	dynamic: boolean;
-	rest: boolean;
-}
-
-export type HttpMethod = 'get' | 'head' | 'post' | 'put' | 'delete' | 'patch';
-
-export interface PageData {
+export interface SSRPage {
 	type: 'page';
-	key: string;
-	shadow: string | null;
-	segments: RouteSegment[];
 	pattern: RegExp;
-	params: string[];
-	path: string;
-	a: string[];
-	b: string[];
+	params: GetParams;
+	shadow:
+		| null
+		| (() => Promise<{
+				[method: string]: ShadowRequestHandler;
+		  }>);
+	/**
+	 * plan a is to render 1 or more layout components followed by a leaf component.
+	 */
+	a: number[];
+	/**
+	 * plan b — if one of them components fails in `load` we backtrack until we find
+	 * the nearest error component.
+	 */
+	b: number[];
 }
 
-export interface EndpointData {
-	type: 'endpoint';
-	key: string;
-	segments: RouteSegment[];
-	pattern: RegExp;
-	params: string[];
-	file: string;
+export interface SSRPagePart {
+	id: string;
+	load: SSRComponentLoader;
 }
 
-export type RouteData = PageData | EndpointData;
+export type SSRRoute = SSREndpoint | SSRPage;
 
-export interface ManifestData {
-	assets: Asset[];
-	layout: string;
-	error: string;
-	components: string[];
-	routes: RouteData[];
+export interface SSRState {
+	fetched?: string;
+	initiator?: SSRPage | null;
+	platform?: any;
+	prerender?: PrerenderOptions;
+	fallback?: string;
 }
 
-export interface BuildData {
-	app_dir: string;
-	manifest_data: ManifestData;
-	service_worker: string | null;
-	client: {
-		assets: OutputAsset[];
-		chunks: OutputChunk[];
-		entry: {
-			file: string;
-			js: string[];
-			css: string[];
-		};
-		vite_manifest: import('vite').Manifest;
-	};
-	server: {
-		chunks: OutputChunk[];
-		methods: Record<string, HttpMethod[]>;
-		vite_manifest: import('vite').Manifest;
-	};
-	static: string[];
-	entries: string[];
-}
+export type StrictBody = string | Uint8Array;
 
-export type NormalizedLoadOutput = Either<
-	{
-		status: number;
-		error?: Error;
-		redirect?: string;
-		props?: Record<string, any> | Promise<Record<string, any>>;
-		stuff?: Record<string, any>;
-		maxage?: number;
-	},
-	Fallthrough
->;
+type ToJSON = { toJSON(...args: any[]): Exclude<JSONValue, ToJSON> };
 
 export type TrailingSlash = 'never' | 'always' | 'ignore';
-export interface MethodOverride {
-	parameter: string;
-	allowed: string[];
-}
 
-export interface Respond {
-	(request: Request, options: SSROptions, state?: SSRState): Promise<Response>;
-}
+export * from './index';

package/types/app.d.ts

@@ -1,35 +0,0 @@
-import { PrerenderOptions, SSRNodeLoader, SSRRoute } from './internal';
-
-export interface RequestOptions<Platform = Record<string, any>> {
-	platform?: Platform;
-}
-
-export class App {
-	constructor(manifest: SSRManifest);
-	render(request: Request, options?: RequestOptions): Promise<Response>;
-}
-
-export class InternalApp extends App {
-	render(
-		request: Request,
-		options?: RequestOptions & {
-			prerender?: PrerenderOptions;
-		}
-	): Promise<Response>;
-}
-
-export interface SSRManifest {
-	appDir: string;
-	assets: Set<string>;
-	/** private fields */
-	_: {
-		mime: Record<string, string>;
-		entry: {
-			file: string;
-			js: string[];
-			css: string[];
-		};
-		nodes: SSRNodeLoader[];
-		routes: SSRRoute[];
-	};
-}

package/types/config.d.ts

@@ -1,200 +0,0 @@
-import { CompileOptions } from 'svelte/types/compiler/interfaces';
-import { UserConfig as ViteConfig } from 'vite';
-import { CspDirectives } from './csp';
-import { MaybePromise, RecursiveRequired } from './helper';
-import { HttpMethod, Logger, RouteSegment, TrailingSlash } from './internal';
-
-export interface RouteDefinition {
-	type: 'page' | 'endpoint';
-	pattern: RegExp;
-	segments: RouteSegment[];
-	methods: HttpMethod[];
-}
-
-export interface AdapterEntry {
-	/**
-	 * A string that uniquely identifies an HTTP service (e.g. serverless function) and is used for deduplication.
-	 * For example, `/foo/a-[b]` and `/foo/[c]` are different routes, but would both
-	 * be represented in a Netlify _redirects file as `/foo/:param`, so they share an ID
-	 */
-	id: string;
-
-	/**
-	 * A function that compares the candidate route with the current route to determine
-	 * if it should be treated as a fallback for the current route. For example, `/foo/[c]`
-	 * is a fallback for `/foo/a-[b]`, and `/[...catchall]` is a fallback for all routes
-	 */
-	filter: (route: RouteDefinition) => boolean;
-
-	/**
-	 * A function that is invoked once the entry has been created. This is where you
-	 * should write the function to the filesystem and generate redirect manifests.
-	 */
-	complete: (entry: {
-		generateManifest: (opts: { relativePath: string; format?: 'esm' | 'cjs' }) => string;
-	}) => void;
-}
-
-export interface Prerendered {
-	pages: Map<
-		string,
-		{
-			/** The location of the .html file relative to the output directory */
-			file: string;
-		}
-	>;
-	assets: Map<
-		string,
-		{
-			/** The MIME type of the asset */
-			type: string;
-		}
-	>;
-	redirects: Map<
-		string,
-		{
-			status: number;
-			location: string;
-		}
-	>;
-	/** An array of prerendered paths (without trailing slashes, regardless of the trailingSlash config) */
-	paths: string[];
-}
-
-export interface Builder {
-	log: Logger;
-	rimraf(dir: string): void;
-	mkdirp(dir: string): void;
-
-	appDir: string;
-	trailingSlash: 'always' | 'never' | 'ignore';
-
-	/**
-	 * Create entry points that map to individual functions
-	 * @param fn A function that groups a set of routes into an entry point
-	 */
-	createEntries(fn: (route: RouteDefinition) => AdapterEntry): void;
-
-	generateManifest: (opts: { relativePath: string; format?: 'esm' | 'cjs' }) => string;
-
-	getBuildDirectory(name: string): string;
-	getClientDirectory(): string;
-	getServerDirectory(): string;
-	getStaticDirectory(): string;
-
-	/**
-	 * @param dest the destination folder to which files should be copied
-	 * @returns an array of paths corresponding to the files that have been created by the copy
-	 */
-	writeClient(dest: string): string[];
-	/**
-	 * @param dest the destination folder to which files should be copied
-	 * @returns an array of paths corresponding to the files that have been created by the copy
-	 */
-	writeServer(dest: string): string[];
-	/**
-	 * @param dest the destination folder to which files should be copied
-	 * @returns an array of paths corresponding to the files that have been created by the copy
-	 */
-	writeStatic(dest: string): string[];
-	/**
-	 * @param from the source file or folder
-	 * @param to the destination file or folder
-	 * @param opts.filter a function to determine whether a file or folder should be copied
-	 * @param opts.replace a map of strings to replace
-	 * @returns an array of paths corresponding to the files that have been created by the copy
-	 */
-	copy(
-		from: string,
-		to: string,
-		opts?: {
-			filter?: (basename: string) => boolean;
-			replace?: Record<string, string>;
-		}
-	): string[];
-
-	prerender(options: { all?: boolean; dest: string; fallback?: string }): Promise<Prerendered>;
-}
-
-export interface Adapter {
-	name: string;
-	headers?: {
-		host?: string;
-		protocol?: string;
-	};
-	adapt(builder: Builder): Promise<void>;
-}
-
-export interface PrerenderErrorHandler {
-	(details: {
-		status: number;
-		path: string;
-		referrer: string | null;
-		referenceType: 'linked' | 'fetched';
-	}): void;
-}
-
-export type PrerenderOnErrorValue = 'fail' | 'continue' | PrerenderErrorHandler;
-
-export interface Config {
-	compilerOptions?: CompileOptions;
-	extensions?: string[];
-	kit?: {
-		adapter?: Adapter;
-		amp?: boolean;
-		appDir?: string;
-		browser?: {
-			hydrate?: boolean;
-			router?: boolean;
-		};
-		csp?: {
-			mode?: 'hash' | 'nonce' | 'auto';
-			directives?: CspDirectives;
-		};
-		files?: {
-			assets?: string;
-			hooks?: string;
-			lib?: string;
-			routes?: string;
-			serviceWorker?: string;
-			template?: string;
-		};
-		floc?: boolean;
-		inlineStyleThreshold?: number;
-		methodOverride?: {
-			parameter?: string;
-			allowed?: string[];
-		};
-		package?: {
-			dir?: string;
-			emitTypes?: boolean;
-			exports?(filepath: string): boolean;
-			files?(filepath: string): boolean;
-		};
-		paths?: {
-			assets?: string;
-			base?: string;
-		};
-		prerender?: {
-			concurrency?: number;
-			crawl?: boolean;
-			enabled?: boolean;
-			entries?: string[];
-			onError?: PrerenderOnErrorValue;
-		};
-		routes?: (filepath: string) => boolean;
-		serviceWorker?: {
-			register?: boolean;
-			files?: (filepath: string) => boolean;
-		};
-		trailingSlash?: TrailingSlash;
-		version?: {
-			name?: string;
-			pollInterval?: number;
-		};
-		vite?: ViteConfig | (() => MaybePromise<ViteConfig>);
-	};
-	preprocess?: any;
-}
-
-export type ValidatedConfig = RecursiveRequired<Config>;