@sveltejs/kit 1.0.0-next.41 → 1.0.0-next.412

package/types/internal.d.ts

@@ -0,0 +1,309 @@
+import { OutputAsset, OutputChunk } from 'rollup';
+import { SvelteComponent } from 'svelte/internal';
+import {
+	Action,
+	Config,
+	ExternalFetch,
+	ServerLoad,
+	GetSession,
+	Handle,
+	HandleError,
+	KitConfig,
+	Load,
+	RequestEvent,
+	RequestHandler,
+	ResolveOptions,
+	Server,
+	ServerInitOptions,
+	SSRManifest
+} from './index.js';
+import { HttpMethod, MaybePromise, RequestOptions, 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 interface CSRPageNode {
+	component: typeof SvelteComponent;
+	shared: {
+		load: Load;
+		hydrate: boolean;
+		router: boolean;
+	};
+	server: boolean;
+}
+
+export type CSRPageNodeLoader = () => Promise<CSRPageNode>;
+
+export type CSRRoute = {
+	id: string;
+	exec: (path: string) => undefined | Record<string, string>;
+	errors: CSRPageNodeLoader[];
+	layouts: CSRPageNodeLoader[];
+	leaf: CSRPageNodeLoader;
+	uses_server_data: 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 interface ImportNode {
+	name: string;
+	dynamic: boolean;
+}
+
+export class InternalServer extends Server {
+	init(options: ServerInitOptions): void;
+	respond(
+		request: Request,
+		options: RequestOptions & {
+			prerendering?: PrerenderOptions;
+		}
+	): Promise<Response>;
+}
+
+export interface ManifestData {
+	assets: Asset[];
+	nodes: PageNode[];
+	routes: RouteData[];
+	matchers: Record<string, string>;
+}
+
+export interface MethodOverride {
+	parameter: string;
+	allowed: string[];
+}
+
+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;
+	pattern: RegExp;
+	errors: Array<PageNode | undefined>;
+	layouts: Array<PageNode | undefined>;
+	leaf: PageNode;
+}
+
+export type PayloadScriptAttributes =
+	| { type: 'data'; url: string; body?: string }
+	| { type: 'server_data' }
+	| { type: 'validation_errors' };
+
+export interface PrerenderDependency {
+	response: Response;
+	body: null | string | Uint8Array;
+}
+
+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>;
+}
+
+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 SSRComponent {
+	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<Partial<Record<HttpMethod, RequestHandler>>>;
+}
+
+export interface SSRNode {
+	component: SSRComponentLoader;
+	/** 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>>;
+
+	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>;
+
+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;
+	};
+	public_env: Record<string, string>;
+	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[];
+	errors: Array<number | undefined>;
+	layouts: Array<number | undefined>;
+	leaf: number;
+}
+
+export interface SSRErrorPage {
+	id: '__error';
+}
+
+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;
+}

package/types/private.d.ts

@@ -0,0 +1,236 @@
+// This module contains types that are visible in the documentation,
+// but which cannot be imported from `@sveltejs/kit`. Care should
+// be taken to avoid breaking changes when editing this file
+
+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;
+	}) => 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
+		: T[P] extends BigInt | Function | Symbol
+		? never
+		: T[P];
+};
+
+// 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.
+
+export namespace Csp {
+	type ActionSource = 'strict-dynamic' | 'report-sample';
+	type BaseSource = 'self' | 'unsafe-eval' | 'unsafe-hashes' | 'unsafe-inline' | 'none';
+	type CryptoSource = `${'nonce' | 'sha256' | 'sha384' | 'sha512'}-${string}`;
+	type FrameSource = HostSource | SchemeSource | 'self' | 'none';
+	type HostNameScheme = `${string}.${string}` | 'localhost';
+	type HostSource = `${HostProtocolSchemes}${HostNameScheme}${PortScheme}`;
+	type HostProtocolSchemes = `${string}://` | '';
+	type HttpDelineator = '/' | '?' | '#' | '\\';
+	type PortScheme = `:${number}` | '' | ':*';
+	type SchemeSource = 'http:' | 'https:' | 'data:' | 'mediastream:' | 'blob:' | 'filesystem:';
+	type Source = HostSource | SchemeSource | CryptoSource | BaseSource;
+	type Sources = Source[];
+	type UriPath = `${HttpDelineator}${string}`;
+}
+
+export interface CspDirectives {
+	'child-src'?: Csp.Sources;
+	'default-src'?: Array<Csp.Source | Csp.ActionSource>;
+	'frame-src'?: Csp.Sources;
+	'worker-src'?: Csp.Sources;
+	'connect-src'?: Csp.Sources;
+	'font-src'?: Csp.Sources;
+	'img-src'?: Csp.Sources;
+	'manifest-src'?: Csp.Sources;
+	'media-src'?: Csp.Sources;
+	'object-src'?: Csp.Sources;
+	'prefetch-src'?: Csp.Sources;
+	'script-src'?: Array<Csp.Source | Csp.ActionSource>;
+	'script-src-elem'?: Csp.Sources;
+	'script-src-attr'?: Csp.Sources;
+	'style-src'?: Array<Csp.Source | Csp.ActionSource>;
+	'style-src-elem'?: Csp.Sources;
+	'style-src-attr'?: Csp.Sources;
+	'base-uri'?: Array<Csp.Source | Csp.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<Csp.Source | Csp.ActionSource>;
+	'frame-ancestors'?: Array<Csp.HostSource | Csp.SchemeSource | Csp.FrameSource>;
+	'navigate-to'?: Array<Csp.Source | Csp.ActionSource>;
+	'report-uri'?: Csp.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'
+	>;
+}
+
+export type HttpMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+
+export interface JSONObject {
+	[key: string]: JSONValue;
+}
+
+export type JSONValue =
+	| string
+	| number
+	| boolean
+	| null
+	| undefined
+	| ToJSON
+	| JSONValue[]
+	| JSONObject;
+
+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 type MaybePromise<T> = T | Promise<T>;
+
+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 PrerenderErrorHandler {
+	(details: {
+		status: number;
+		path: string;
+		referrer: string | null;
+		referenceType: 'linked' | 'fetched';
+	}): void;
+}
+
+export type PrerenderOnErrorValue = 'fail' | 'continue' | PrerenderErrorHandler;
+
+export interface RequestOptions {
+	getClientAddress: () => string;
+	platform?: App.Platform;
+}
+
+/** `string[]` is only for set-cookie, everything else must be type of `string` */
+export type ResponseHeaders = Record<string, string | number | string[] | null>;
+
+export interface RouteDefinition {
+	id: string;
+	type: 'page' | 'endpoint';
+	pattern: RegExp;
+	segments: RouteSegment[];
+	methods: HttpMethod[];
+}
+
+export interface RouteSegment {
+	content: string;
+	dynamic: boolean;
+	rest: boolean;
+}
+
+export interface ToJSON {
+	toJSON(...args: any[]): Exclude<JSONValue, ToJSON>;
+}
+
+export type TrailingSlash = 'never' | 'always' | 'ignore';