@sveltejs/kit 1.0.0-next.27 → 1.0.0-next.273

package/types/config.d.ts

@@ -0,0 +1,200 @@
+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>;

package/types/csp.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Based on https://github.com/josh-hemphill/csp-typed-directives/blob/latest/src/csp.types.ts
+ *
+ * MIT License
+ *
+ * Copyright (c) 2021-present, Joshua Hemphill
+ * Copyright (c) 2021, Tecnico Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+type SchemeSource = 'http:' | 'https:' | 'data:' | 'mediastream:' | 'blob:' | 'filesystem:';
+
+type HostProtocolSchemes = `${string}://` | '';
+type PortScheme = `:${number}` | '' | ':*';
+/** Can actually be any string, but typed more explicitly to
+ *  restrict the combined optional types of Source from collapsing to just bing `string` */
+type HostNameScheme = `${string}.${string}` | `localhost`;
+type HostSource = `${HostProtocolSchemes}${HostNameScheme}${PortScheme}`;
+
+type CryptoSource = `${'nonce' | 'sha256' | 'sha384' | 'sha512'}-${string}`;
+
+type BaseSource = 'self' | 'unsafe-eval' | 'unsafe-hashes' | 'unsafe-inline' | 'none';
+
+export type Source = HostSource | SchemeSource | CryptoSource | BaseSource;
+type Sources = Source[];
+
+type ActionSource = 'strict-dynamic' | 'report-sample';
+
+type FrameSource = HostSource | SchemeSource | 'self' | 'none';
+
+type HttpDelineator = '/' | '?' | '#' | '\\';
+type UriPath = `${HttpDelineator}${string}`;
+
+export type CspDirectives = {
+	'child-src'?: Sources;
+	'default-src'?: Array<Source | ActionSource>;
+	'frame-src'?: Sources;
+	'worker-src'?: Sources;
+	'connect-src'?: Sources;
+	'font-src'?: Sources;
+	'img-src'?: Sources;
+	'manifest-src'?: Sources;
+	'media-src'?: Sources;
+	'object-src'?: Sources;
+	'prefetch-src'?: Sources;
+	'script-src'?: Array<Source | ActionSource>;
+	'script-src-elem'?: Sources;
+	'script-src-attr'?: Sources;
+	'style-src'?: Array<Source | ActionSource>;
+	'style-src-elem'?: Sources;
+	'style-src-attr'?: Sources;
+	'base-uri'?: Array<Source | ActionSource>;
+	sandbox?: Array<
+		| 'allow-downloads-without-user-activation'
+		| 'allow-forms'
+		| 'allow-modals'
+		| 'allow-orientation-lock'
+		| 'allow-pointer-lock'
+		| 'allow-popups'
+		| 'allow-popups-to-escape-sandbox'
+		| 'allow-presentation'
+		| 'allow-same-origin'
+		| 'allow-scripts'
+		| 'allow-storage-access-by-user-activation'
+		| 'allow-top-navigation'
+		| 'allow-top-navigation-by-user-activation'
+	>;
+	'form-action'?: Array<Source | ActionSource>;
+	'frame-ancestors'?: Array<HostSource | SchemeSource | FrameSource>;
+	'navigate-to'?: Array<Source | ActionSource>;
+	'report-uri'?: UriPath[];
+	'report-to'?: string[];
+
+	'require-trusted-types-for'?: Array<'script'>;
+	'trusted-types'?: Array<'none' | 'allow-duplicates' | '*' | string>;
+	'upgrade-insecure-requests'?: boolean;
+
+	/** @deprecated */
+	'require-sri-for'?: Array<'script' | 'style' | 'script style'>;
+
+	/** @deprecated */
+	'block-all-mixed-content'?: boolean;
+
+	/** @deprecated */
+	'plugin-types'?: Array<`${string}/${string}` | 'none'>;
+
+	/** @deprecated */
+	referrer?: Array<
+		| 'no-referrer'
+		| 'no-referrer-when-downgrade'
+		| 'origin'
+		| 'origin-when-cross-origin'
+		| 'same-origin'
+		| 'strict-origin'
+		| 'strict-origin-when-cross-origin'
+		| 'unsafe-url'
+		| 'none'
+	>;
+};

package/types/endpoint.d.ts

@@ -0,0 +1,39 @@
+import { RequestEvent } from './hooks';
+import { Either, JSONObject, JSONValue, MaybePromise, ResponseHeaders } from './helper';
+
+type Body = JSONValue | Uint8Array | ReadableStream | import('stream').Readable;
+
+export interface EndpointOutput<Output extends Body = Body> {
+	status?: number;
+	headers?: Headers | Partial<ResponseHeaders>;
+	body?: Output;
+}
+
+export interface Fallthrough {
+	fallthrough: true;
+}
+
+export interface RequestHandler<Output extends Body = Body> {
+	(event: RequestEvent): MaybePromise<
+		Either<Output extends Response ? Response : EndpointOutput<Output>, Fallthrough>
+	>;
+}
+
+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;
+}

package/types/helper.d.ts

@@ -0,0 +1,23 @@
+type ToJSON = { toJSON(...args: any[]): Exclude<JSONValue, ToJSON> };
+
+export type JSONObject = { [key: string]: JSONValue };
+export type JSONValue = string | number | boolean | null | ToJSON | JSONValue[] | JSONObject;
+
+/** `string[]` is only for set-cookie, everything else must be type of `string` */
+export type ResponseHeaders = Record<string, string | number | string[]>;
+
+// <-- Utility Types -->
+type Only<T, U> = { [P in keyof T]: T[P] } & { [P in Exclude<keyof U, keyof T>]?: never };
+
+export type Either<T, U> = Only<T, U> | Only<U, T>;
+export type MaybePromise<T> = T | Promise<T>;
+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
+};

package/types/hooks.d.ts

@@ -0,0 +1,37 @@
+import { MaybePromise } from './helper';
+
+export type StrictBody = string | Uint8Array;
+
+export interface RequestEvent {
+	request: Request;
+	url: URL;
+	params: Record<string, string>;
+	locals: App.Locals;
+	platform: Readonly<App.Platform>;
+}
+
+export interface GetSession {
+	(event: RequestEvent): MaybePromise<App.Session>;
+}
+
+export interface RequiredResolveOptions {
+	ssr: boolean;
+	transformPage: ({ html }: { html: string }) => string;
+}
+
+export type ResolveOptions = Partial<RequiredResolveOptions>;
+
+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;
+}
+
+export interface ExternalFetch {
+	(req: Request): Promise<Response>;
+}

package/types/index.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="svelte" />
+/// <reference types="vite/client" />
+
+import './ambient-modules';
+
+export { App, SSRManifest } from './app';
+export {
+	Adapter,
+	Builder,
+	Config,
+	Prerendered,
+	PrerenderErrorHandler,
+	ValidatedConfig
+} from './config';
+export { EndpointOutput, RequestHandler } from './endpoint';
+export { ErrorLoad, ErrorLoadInput, Load, LoadInput, LoadOutput } from './page';
+export {
+	ExternalFetch,
+	GetSession,
+	Handle,
+	HandleError,
+	RequestEvent,
+	ResolveOptions
+} from './hooks';

package/types/internal.d.ts

@@ -0,0 +1,260 @@
+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';
+
+export interface PrerenderDependency {
+	response: Response;
+	body: null | string | Uint8Array;
+}
+
+export interface PrerenderOptions {
+	fallback?: string;
+	all: boolean;
+	dependencies: Map<string, PrerenderDependency>;
+}
+
+export interface AppModule {
+	App: typeof InternalApp;
+
+	override(options: {
+		paths: {
+			base: string;
+			assets: string;
+		};
+		prerendering: boolean;
+		protocol?: 'http' | 'https';
+		read(file: string): Buffer;
+	}): void;
+}
+
+export interface Logger {
+	(msg: string): void;
+	success(msg: string): void;
+	error(msg: string): void;
+	warn(msg: string): void;
+	minor(msg: string): void;
+	info(msg: string): void;
+}
+
+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 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;
+	params: GetParams;
+	load(): Promise<{
+		[method: string]: RequestHandler;
+	}>;
+}
+
+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 */
+	entry: string;
+	/** external CSS files */
+	css: string[];
+	/** external JS files */
+	js: string[];
+	/** inlined styles */
+	styles?: Record<string, string>;
+}
+
+export interface SSROptions {
+	amp: boolean;
+	csp: ValidatedConfig['kit']['csp'];
+	dev: boolean;
+	floc: 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: 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 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 {
+	type: 'page';
+	key: string;
+	shadow: string | null;
+	segments: RouteSegment[];
+	pattern: RegExp;
+	params: string[];
+	path: string;
+	a: string[];
+	b: string[];
+}
+
+export interface EndpointData {
+	type: 'endpoint';
+	key: string;
+	segments: RouteSegment[];
+	pattern: RegExp;
+	params: string[];
+	file: string;
+}
+
+export type RouteData = PageData | EndpointData;
+
+export interface ManifestData {
+	assets: Asset[];
+	layout: string;
+	error: string;
+	components: string[];
+	routes: RouteData[];
+}
+
+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 NormalizedLoadOutput = Either<
+	{
+		status: number;
+		error?: Error;
+		redirect?: string;
+		props?: Record<string, any> | Promise<Record<string, any>>;
+		stuff?: Record<string, any>;
+		maxage?: number;
+	},
+	Fallthrough
+>;
+
+export type TrailingSlash = 'never' | 'always' | 'ignore';
+export interface MethodOverride {
+	parameter: string;
+	allowed: string[];
+}
+
+export interface Respond {
+	(request: Request, options: SSROptions, state?: SSRState): Promise<Response>;
+}