@sveltejs/kit 1.0.0-next.39 → 1.0.0-next.392

package/types/index.d.ts

@@ -0,0 +1,290 @@
+/// <reference types="svelte" />
+/// <reference types="vite/client" />
+
+import './ambient.js';
+
+import { CompileOptions } from 'svelte/types/compiler/interfaces';
+import {
+	AdapterEntry,
+	BodyValidator,
+	CspDirectives,
+	JSONValue,
+	Logger,
+	MaybePromise,
+	Prerendered,
+	PrerenderOnErrorValue,
+	RequestOptions,
+	ResponseHeaders,
+	RouteDefinition,
+	TrailingSlash
+} from './private.js';
+import { SSRNodeLoader, SSRRoute, ValidatedConfig } from './internal.js';
+
+export interface Adapter {
+	name: string;
+	adapt(builder: Builder): MaybePromise<void>;
+}
+
+export interface Builder {
+	log: Logger;
+	rimraf(dir: string): void;
+	mkdirp(dir: string): void;
+
+	config: ValidatedConfig;
+	prerendered: Prerendered;
+
+	/**
+	 * 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): Promise<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
+	 */
+	writePrerendered(
+		dest: string,
+		opts?: {
+			fallback?: 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 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[];
+}
+
+export interface Config {
+	compilerOptions?: CompileOptions;
+	extensions?: string[];
+	kit?: KitConfig;
+	preprocess?: any;
+}
+
+export interface KitConfig {
+	adapter?: Adapter;
+	alias?: Record<string, string>;
+	appDir?: string;
+	browser?: {
+		hydrate?: boolean;
+		router?: boolean;
+	};
+	csp?: {
+		mode?: 'hash' | 'nonce' | 'auto';
+		directives?: CspDirectives;
+		reportOnly?: CspDirectives;
+	};
+	moduleExtensions?: string[];
+	files?: {
+		assets?: string;
+		hooks?: string;
+		lib?: string;
+		params?: string;
+		routes?: string;
+		serviceWorker?: string;
+		template?: string;
+	};
+	inlineStyleThreshold?: number;
+	methodOverride?: {
+		parameter?: string;
+		allowed?: string[];
+	};
+	outDir?: string;
+	package?: {
+		dir?: string;
+		emitTypes?: boolean;
+		exports?(filepath: string): boolean;
+		files?(filepath: string): boolean;
+	};
+	paths?: {
+		assets?: string;
+		base?: string;
+	};
+	prerender?: {
+		concurrency?: number;
+		crawl?: boolean;
+		default?: boolean;
+		enabled?: boolean;
+		entries?: Array<'*' | `/${string}`>;
+		onError?: PrerenderOnErrorValue;
+		origin?: string;
+	};
+	routes?: (filepath: string) => boolean;
+	serviceWorker?: {
+		register?: boolean;
+		files?: (filepath: string) => boolean;
+	};
+	trailingSlash?: TrailingSlash;
+	version?: {
+		name?: string;
+		pollInterval?: number;
+	};
+}
+
+export interface ExternalFetch {
+	(req: Request): Promise<Response>;
+}
+
+export interface GetSession {
+	(event: RequestEvent): MaybePromise<App.Session>;
+}
+
+export interface Handle {
+	(input: {
+		event: RequestEvent;
+		resolve(event: RequestEvent, opts?: ResolveOptions): MaybePromise<Response>;
+	}): MaybePromise<Response>;
+}
+
+export interface HandleError {
+	(input: { error: Error & { frame?: string }; event: RequestEvent }): void;
+}
+
+/**
+ * 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.
+ */
+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
+> {
+	(event: LoadEvent<Params, InputProps>): MaybePromise<LoadOutput<OutputProps> | void>;
+}
+
+export interface LoadEvent<
+	Params extends Record<string, string> = Record<string, string>,
+	Props extends Record<string, any> = Record<string, any>
+> {
+	fetch(info: RequestInfo, init?: RequestInit): Promise<Response>;
+	params: Params;
+	props: Props;
+	routeId: string | null;
+	session: App.Session;
+	stuff: Partial<App.Stuff>;
+	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;
+}
+
+export interface Navigation {
+	from: URL;
+	to: URL;
+}
+
+export interface Page<Params extends Record<string, string> = Record<string, string>> {
+	url: URL;
+	params: Params;
+	routeId: string | null;
+	stuff: App.Stuff;
+	status: number;
+	error: Error | null;
+}
+
+export interface ParamMatcher {
+	(param: string): boolean;
+}
+
+export interface RequestEvent<Params extends Record<string, string> = Record<string, string>> {
+	clientAddress: string;
+	locals: App.Locals;
+	params: Params;
+	platform: Readonly<App.Platform>;
+	request: Request;
+	routeId: string | null;
+	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.
+ *
+ * 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 ResolveOptions {
+	ssr?: boolean;
+	transformPageChunk?: (input: { html: string; done: boolean }) => MaybePromise<string | undefined>;
+}
+
+export type ResponseBody = JSONValue | Uint8Array | ReadableStream | Error;
+
+export class Server {
+	constructor(manifest: SSRManifest);
+	respond(request: Request, options: RequestOptions): Promise<Response>;
+}
+
+export interface SSRManifest {
+	appDir: string;
+	assets: Set<string>;
+	mimeTypes: Record<string, string>;
+
+	/** private fields */
+	_: {
+		entry: {
+			file: string;
+			imports: string[];
+			stylesheets: string[];
+		};
+		nodes: SSRNodeLoader[];
+		routes: SSRRoute[];
+		matchers: () => Promise<Record<string, ParamMatcher>>;
+	};
+}

package/types/internal.d.ts

@@ -0,0 +1,327 @@
+import { OutputAsset, OutputChunk } from 'rollup';
+import {
+	Config,
+	ExternalFetch,
+	GetSession,
+	Handle,
+	HandleError,
+	KitConfig,
+	Load,
+	RequestEvent,
+	RequestHandler,
+	ResolveOptions,
+	Server,
+	SSRManifest
+} from './index.js';
+import {
+	HttpMethod,
+	JSONObject,
+	MaybePromise,
+	RequestOptions,
+	ResponseHeaders,
+	TrailingSlash
+} from './private.js';
+
+export interface ServerModule {
+	Server: typeof InternalServer;
+
+	override(options: {
+		paths: {
+			base: string;
+			assets: string;
+		};
+		prerendering: boolean;
+		protocol?: 'http' | 'https';
+		read(file: string): Buffer;
+	}): void;
+}
+
+export interface Asset {
+	file: string;
+	size: number;
+	type: string | null;
+}
+
+export interface BuildData {
+	app_dir: string;
+	manifest_data: ManifestData;
+	service_worker: string | null;
+	client: {
+		assets: OutputAsset[];
+		chunks: OutputChunk[];
+		entry: {
+			file: string;
+			imports: string[];
+			stylesheets: string[];
+		};
+		vite_manifest: import('vite').Manifest;
+	};
+	server: {
+		chunks: OutputChunk[];
+		methods: Record<string, HttpMethod[]>;
+		vite_manifest: import('vite').Manifest;
+	};
+}
+
+export type CSRComponent = any; // TODO
+
+export type CSRComponentLoader = () => Promise<CSRComponent>;
+
+export type CSRRoute = {
+	id: string;
+	exec: (path: string) => undefined | Record<string, string>;
+	a: CSRComponentLoader[];
+	b: CSRComponentLoader[];
+	has_shadow: boolean;
+};
+
+export interface EndpointData {
+	type: 'endpoint';
+	id: string;
+	pattern: RegExp;
+	file: string;
+}
+
+export type GetParams = (match: RegExpExecArray) => Record<string, string>;
+
+export interface Hooks {
+	externalFetch: ExternalFetch;
+	getSession: GetSession;
+	handle: Handle;
+	handleError: HandleError;
+}
+
+export class InternalServer extends Server {
+	respond(
+		request: Request,
+		options: RequestOptions & {
+			prerendering?: PrerenderOptions;
+		}
+	): Promise<Response>;
+}
+
+export interface ManifestData {
+	assets: Asset[];
+	components: string[];
+	routes: RouteData[];
+	matchers: Record<string, string>;
+}
+
+export interface MethodOverride {
+	parameter: string;
+	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 PageData {
+	type: 'page';
+	id: string;
+	shadow: string | null;
+	pattern: RegExp;
+	path: string;
+	a: Array<string | undefined>;
+	b: Array<string | undefined>;
+}
+
+export type PayloadScriptAttributes =
+	| { type: 'data'; url: string; body?: string }
+	| { type: 'props' };
+
+export interface PrerenderDependency {
+	response: Response;
+	body: null | string | Uint8Array;
+}
+
+export interface PrerenderOptions {
+	fallback?: boolean;
+	dependencies: Map<string, PrerenderDependency>;
+}
+
+export type RecursiveRequired<T> = {
+	// Recursive implementation of TypeScript's Required utility type.
+	// Will recursively continue until it reaches a primitive or Function
+	[K in keyof T]-?: Extract<T[K], Function> extends never // If it does not have a Function type
+		? RecursiveRequired<T[K]> // recursively continue through.
+		: T[K]; // Use the exact type for everything else
+};
+
+export type RequiredResolveOptions = Required<ResolveOptions>;
+
+export interface Respond {
+	(request: Request, options: SSROptions, state: SSRState): Promise<Response>;
+}
+
+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;
+			head: string;
+			css: {
+				code: string;
+				map: any; // TODO
+			};
+		};
+	};
+}
+
+export type SSRComponentLoader = () => Promise<SSRComponent>;
+
+export interface SSREndpoint {
+	type: 'endpoint';
+	id: string;
+	pattern: RegExp;
+	names: string[];
+	types: string[];
+	load(): Promise<{
+		[method: string]: RequestHandler;
+	}>;
+}
+
+export interface SSRNode {
+	module: SSRComponent;
+	/** index into the `components` array in client-manifest.js */
+	index: number;
+	/** client-side module URL for this component */
+	file: string;
+	/** external JS files */
+	imports: string[];
+	/** external CSS files */
+	stylesheets: string[];
+	/** inlined styles */
+	inline_styles?: () => MaybePromise<Record<string, string>>;
+}
+
+export type SSRNodeLoader = () => Promise<SSRNode>;
+
+export interface SSROptions {
+	csp: ValidatedConfig['kit']['csp'];
+	dev: boolean;
+	get_stack: (error: Error) => string | undefined;
+	handle_error(error: Error & { frame?: string }, event: RequestEvent): void;
+	hooks: Hooks;
+	hydrate: boolean;
+	manifest: SSRManifest;
+	method_override: MethodOverride;
+	paths: {
+		base: string;
+		assets: string;
+	};
+	prefix: string;
+	prerender: {
+		default: boolean;
+		enabled: boolean;
+	};
+	read(file: string): Buffer;
+	root: SSRComponent['default'];
+	router: boolean;
+	service_worker?: string;
+	template({
+		head,
+		body,
+		assets,
+		nonce
+	}: {
+		head: string;
+		body: string;
+		assets: string;
+		nonce: string;
+	}): string;
+	template_contains_nonce: boolean;
+	trailing_slash: TrailingSlash;
+}
+
+export interface SSRPage {
+	type: 'page';
+	id: string;
+	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>;
+}
+
+export interface SSRErrorPage {
+	id: '__error';
+}
+
+export interface SSRPagePart {
+	id: string;
+	load: SSRComponentLoader;
+}
+
+export type SSRRoute = SSREndpoint | SSRPage;
+
+export interface SSRState {
+	fallback?: string;
+	getClientAddress: () => string;
+	initiator?: SSRPage | SSRErrorPage;
+	platform?: any;
+	prerendering?: PrerenderOptions;
+}
+
+export type StrictBody = string | Uint8Array;
+
+export type ValidatedConfig = RecursiveRequired<Config>;
+
+export type ValidatedKitConfig = RecursiveRequired<KitConfig>;
+
+export * from './index';
+export * from './private';
+
+declare global {
+	const __SVELTEKIT_ADAPTER_NAME__: string;
+	const __SVELTEKIT_APP_VERSION__: string;
+	const __SVELTEKIT_APP_VERSION_FILE__: string;
+	const __SVELTEKIT_APP_VERSION_POLL_INTERVAL__: number;
+	const __SVELTEKIT_DEV__: boolean;
+}