@sveltejs/kit 1.0.0-next.34 → 1.0.0-next.342

package/types/ambient.d.ts

@@ -0,0 +1,307 @@
+/**
+ * It's possible to tell SvelteKit how to type objects inside your app by declaring the `App` namespace. By default, a new project will have a file called `src/app.d.ts` containing the following:
+ *
+ * ```ts
+ * /// <reference types="@sveltejs/kit" />
+ *
+ * declare namespace App {
+ * 	interface Locals {}
+ *
+ * 	interface Platform {}
+ *
+ * 	interface Session {}
+ *
+ * 	interface Stuff {}
+ * }
+ * ```
+ *
+ * By populating these interfaces, you will gain type safety when using `event.locals`, `event.platform`, `session` and `stuff`.
+ *
+ * Note that since it's an ambient declaration file, you can't use `import` statements — instead, use the `import(...)` function:
+ *
+ * ```ts
+ * interface Locals {
+ * 	user: import('$lib/types').User;
+ * }
+ * ```
+ */
+declare namespace App {
+	/**
+	 * The interface that defines `event.locals`, which can be accessed in [hooks](/docs/hooks) (`handle`, `handleError` and `getSession`) and [endpoints](/docs/routing#endpoints).
+	 */
+	export interface Locals {}
+
+	/**
+	 * If your adapter provides [platform-specific context](/docs/adapters#supported-environments-platform-specific-context) via `event.platform`, you can specify it here.
+	 */
+	export interface Platform {}
+
+	/**
+	 * The interface that defines `session`, both as an argument to [`load`](/docs/loading) functions and the value of the [session store](/docs/modules#$app-stores).
+	 */
+	export interface Session {}
+
+	/**
+	 * The interface that defines `stuff`, as input or output to [`load`](/docs/loading) or as the value of the `stuff` property of the [page store](/docs/modules#$app-stores).
+	 */
+	export interface Stuff {}
+}
+
+/**
+ * ```ts
+ * import { browser, dev, mode, prerendering } from '$app/env';
+ * ```
+ */
+declare module '$app/env' {
+	/**
+	 * Whether the app is running in the browser or on the server.
+	 */
+	export const browser: boolean;
+	/**
+	 * `true` in development mode, `false` in production.
+	 */
+	export const dev: boolean;
+	/**
+	 * `true` when prerendering, `false` otherwise.
+	 */
+	export const prerendering: boolean;
+	/**
+	 * The Vite.js mode the app is running in. Configure in `config.kit.vite.mode`.
+	 * Vite.js loads the dotenv file associated with the provided mode, `.env.[mode]` or `.env.[mode].local`.
+	 * By default, `svelte-kit dev` runs with `mode=development` and `svelte-kit build` runs with `mode=production`.
+	 */
+	export const mode: string;
+}
+
+/**
+ * ```ts
+ * import {
+ * 	afterNavigate,
+ * 	beforeNavigate,
+ * 	disableScrollHandling,
+ * 	goto,
+ * 	invalidate,
+ * 	prefetch,
+ * 	prefetchRoutes
+ * } from '$app/navigation';
+ * ```
+ */
+declare module '$app/navigation' {
+	/**
+	 * If called when the page is being updated following a navigation (in `onMount` or `afterNavigate` or an action, for example), this disables SvelteKit's built-in scroll handling.
+	 * This is generally discouraged, since it breaks user expectations.
+	 */
+	export function disableScrollHandling(): void;
+	/**
+	 * Returns a Promise that resolves when SvelteKit navigates (or fails to navigate, in which case the promise rejects) to the specified `href`.
+	 *
+	 * @param href Where to navigate to
+	 * @param opts.replaceState If `true`, will replace the current `history` entry rather than creating a new one with `pushState`
+	 * @param opts.noscroll If `true`, the browser will maintain its scroll position rather than scrolling to the top of the page after navigation
+	 * @param opts.keepfocus If `true`, the currently focused element will retain focus after navigation. Otherwise, focus will be reset to the body
+	 * @param opts.state The state of the new/updated history entry
+	 */
+	export function goto(
+		href: string,
+		opts?: { replaceState?: boolean; noscroll?: boolean; keepfocus?: boolean; state?: any }
+	): Promise<void>;
+	/**
+	 * Causes any `load` functions belonging to the currently active page to re-run if they `fetch` the resource in question. Returns a `Promise` that resolves when the page is subsequently updated.
+	 * @param dependency The invalidated resource
+	 */
+	export function invalidate(dependency: string | ((href: string) => boolean)): Promise<void>;
+	/**
+	 * Programmatically prefetches the given page, which means
+	 *  1. ensuring that the code for the page is loaded, and
+	 *  2. calling the page's load function with the appropriate options.
+	 *
+	 * This is the same behaviour that SvelteKit triggers when the user taps or mouses over an `<a>` element with `sveltekit:prefetch`.
+	 * If the next navigation is to `href`, the values returned from load will be used, making navigation instantaneous.
+	 * Returns a Promise that resolves when the prefetch is complete.
+	 *
+	 * @param href Page to prefetch
+	 */
+	export function prefetch(href: string): Promise<void>;
+	/**
+	 * Programmatically prefetches the code for routes that haven't yet been fetched.
+	 * Typically, you might call this to speed up subsequent navigation.
+	 *
+	 * If no argument is given, all routes will be fetched, otherwise you can specify routes by any matching pathname
+	 * such as `/about` (to match `src/routes/about.svelte`) or `/blog/*` (to match `src/routes/blog/[slug].svelte`).
+	 *
+	 * Unlike prefetch, this won't call load for individual pages.
+	 * Returns a Promise that resolves when the routes have been prefetched.
+	 */
+	export function prefetchRoutes(routes?: string[]): Promise<void>;
+
+	/**
+	 * A navigation interceptor that triggers before we navigate to a new URL (internal or external) whether by clicking a link, calling `goto`, or using the browser back/forward controls.
+	 * This is helpful if we want to conditionally prevent a navigation from completing or lookup the upcoming url.
+	 */
+	export function beforeNavigate(
+		fn: (navigation: { from: URL; to: URL | null; cancel: () => void }) => void
+	): void;
+
+	/**
+	 * A lifecycle function that runs when the page mounts, and also whenever SvelteKit navigates to a new URL but stays on this component.
+	 */
+	export function afterNavigate(fn: (navigation: { from: URL | null; to: URL }) => void): void;
+}
+
+/**
+ * ```ts
+ * import { base, assets } from '$app/paths';
+ * ```
+ */
+declare module '$app/paths' {
+	/**
+	 * A string that matches [`config.kit.paths.base`](/docs/configuration#paths). It must start, but not end with `/` (e.g. `/base-path`), unless it is the empty string.
+	 */
+	export const base: `/${string}`;
+	/**
+	 * An absolute path that matches [`config.kit.paths.assets`](/docs/configuration#paths).
+	 *
+	 * > If a value for `config.kit.paths.assets` is specified, it will be replaced with `'/_svelte_kit_assets'` during [`svelte-kit dev`](/docs/cli#svelte-kit-dev) or [`svelte-kit preview`](/docs/cli#svelte-kit-preview), since the assets don't yet live at their eventual URL.
+	 */
+	export const assets: `https://${string}` | `http://${string}`;
+}
+
+/**
+ * ```ts
+ * import { getStores, navigating, page, session, updated } from '$app/stores';
+ * ```
+ *
+ * Stores are _contextual_ — they are added to the [context](https://svelte.dev/tutorial/context-api) of your root component. This means that `session` and `page` are unique to each request on the server, rather than shared between multiple requests handled by the same server simultaneously, which is what makes it safe to include user-specific data in `session`.
+ *
+ * Because of that, you must subscribe to the stores during component initialization (which happens automatically if you reference the store value, e.g. as `$page`, in a component) before you can use them.
+ */
+declare module '$app/stores' {
+	import { Readable, Writable } from 'svelte/store';
+	import { Navigation, Page } from '@sveltejs/kit';
+
+	/**
+	 * A convenience function around `getContext`. Must be called during component initialization.
+	 * Only use this if you need to defer store subscription until after the component has mounted, for some reason.
+	 */
+	export function getStores(): {
+		navigating: typeof navigating;
+		page: typeof page;
+		session: typeof session;
+		updated: typeof updated;
+	};
+
+	/**
+	 * A readable store whose value contains page data.
+	 */
+	export const page: Readable<Page>;
+	/**
+	 * A readable store.
+	 * When navigating starts, its value is `{ from: URL, to: URL }`,
+	 * When navigating finishes, its value reverts to `null`.
+	 */
+	export const navigating: Readable<Navigation | null>;
+	/**
+	 * A writable store whose initial value is whatever was returned from [`getSession`](/docs/hooks#getsession).
+	 * It can be written to, but this will not cause changes to persist on the server — this is something you must implement yourself.
+	 */
+	export const session: Writable<App.Session>;
+	/**
+	 *  A readable store whose initial value is `false`. If [`version.pollInterval`](/docs/configuration#version) is a non-zero value, SvelteKit will poll for new versions of the app and update the store value to `true` when it detects one. `updated.check()` will force an immediate check, regardless of polling.
+	 */
+	export const updated: Readable<boolean> & { check: () => boolean };
+}
+
+/**
+ * ```ts
+ * import { build, files, prerendered, version } from '$service-worker';
+ * ```
+ *
+ * This module is only available to [service workers](/docs/service-workers).
+ */
+declare module '$service-worker' {
+	/**
+	 * An array of URL strings representing the files generated by Vite, suitable for caching with `cache.addAll(build)`.
+	 */
+	export const build: string[];
+	/**
+	 * An array of URL strings representing the files in your static directory, or whatever directory is specified by `config.kit.files.assets`. You can customize which files are included from `static` directory using [`config.kit.serviceWorker.files`](/docs/configuration)
+	 */
+	export const files: string[];
+	/**
+	 * An array of pathnames corresponding to prerendered pages and endpoints.
+	 */
+	export const prerendered: string[];
+	/**
+	 * See [`config.kit.version`](/docs/configuration#version). It's useful for generating unique cache names inside your service worker, so that a later deployment of your app can invalidate old caches.
+	 */
+	export const version: string;
+}
+
+declare module '@sveltejs/kit/hooks' {
+	import { Handle } from '@sveltejs/kit';
+
+	/**
+	 * A helper function for sequencing multiple `handle` calls in a middleware-like manner.
+	 *
+	 * ```js
+	 * /// file: src/hooks.js
+	 * import { sequence } from '@sveltejs/kit/hooks';
+	 *
+	 * /** @type {import('@sveltejs/kit').Handle} *\/
+	 * async function first({ event, resolve }) {
+	 * 	console.log('first pre-processing');
+	 * 	const result = await resolve(event);
+	 * 	console.log('first post-processing');
+	 * 	return result;
+	 * }
+	 *
+	 * /** @type {import('@sveltejs/kit').Handle} *\/
+	 * async function second({ event, resolve }) {
+	 * 	console.log('second pre-processing');
+	 * 	const result = await resolve(event);
+	 * 	console.log('second post-processing');
+	 * 	return result;
+	 * }
+	 *
+	 * export const handle = sequence(first, second);
+	 * ```
+	 *
+	 * The example above would print:
+	 *
+	 * ```
+	 * first pre-processing
+	 * second pre-processing
+	 * second post-processing
+	 * first post-processing
+	 * ```
+	 *
+	 * @param handlers The chain of `handle` functions
+	 */
+	export function sequence(...handlers: Handle[]): Handle;
+}
+
+/**
+ * A polyfill for `fetch` and its related interfaces, used by adapters for environments that don't provide a native implementation.
+ */
+declare module '@sveltejs/kit/node/polyfills' {
+	/**
+	 * Make various web APIs available as globals:
+	 * - `crypto`
+	 * - `fetch`
+	 * - `Headers`
+	 * - `Request`
+	 * - `Response`
+	 */
+	export function installPolyfills(): void;
+}
+
+/**
+ * Utilities used by adapters for Node-like environments.
+ */
+declare module '@sveltejs/kit/node' {
+	export function getRequest(
+		base: string,
+		request: import('http').IncomingMessage
+	): Promise<Request>;
+	export function setResponse(res: import('http').ServerResponse, response: Response): void;
+}

package/types/index.d.ts

@@ -0,0 +1,292 @@
+/// <reference types="svelte" />
+/// <reference types="vite/client" />
+
+import './ambient';
+
+import { CompileOptions } from 'svelte/types/compiler/interfaces';
+import {
+	AdapterEntry,
+	BodyValidator,
+	CspDirectives,
+	JSONValue,
+	Logger,
+	MaybePromise,
+	Prerendered,
+	PrerenderOnErrorValue,
+	RequestOptions,
+	ResponseHeaders,
+	RouteDefinition,
+	TrailingSlash
+} from './private';
+import { SSRNodeLoader, SSRRoute, ValidatedConfig } from './internal';
+
+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 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[];
+}
+
+export interface Config {
+	compilerOptions?: CompileOptions;
+	extensions?: string[];
+	kit?: {
+		adapter?: Adapter;
+		alias?: Record<string, string>;
+		appDir?: string;
+		browser?: {
+			hydrate?: boolean;
+			router?: boolean;
+		};
+		csp?: {
+			mode?: 'hash' | 'nonce' | 'auto';
+			directives?: CspDirectives;
+		};
+		endpointExtensions?: string[];
+		files?: {
+			assets?: string;
+			hooks?: string;
+			lib?: string;
+			params?: string;
+			routes?: string;
+			serviceWorker?: string;
+			template?: string;
+		};
+		floc?: boolean;
+		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;
+		};
+		routes?: (filepath: string) => boolean;
+		serviceWorker?: {
+			register?: boolean;
+			files?: (filepath: string) => boolean;
+		};
+		trailingSlash?: TrailingSlash;
+		version?: {
+			name?: string;
+			pollInterval?: number;
+		};
+		vite?: import('vite').UserConfig | (() => MaybePromise<import('vite').UserConfig>);
+	};
+	preprocess?: any;
+}
+
+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>>;
+}
+
+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. Note that since 'delete' is a reserved word in JavaScript, delete handles are called `del` instead.
+ *
+ * Note that you can use [generated types](/docs/types#generated-types) instead of manually specifying the `Params` generic argument.
+ */
+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;
+	transformPage?: ({ html }: { html: string }) => MaybePromise<string>;
+}
+
+export type ResponseBody = JSONValue | Uint8Array | ReadableStream | import('stream').Readable;
+
+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;
+			js: string[];
+			css: string[];
+		};
+		nodes: SSRNodeLoader[];
+		routes: SSRRoute[];
+		matchers: () => Promise<Record<string, ParamMatcher>>;
+	};
+}