@sveltejs/kit 1.0.0-next.44 → 1.0.0-next.442

package/types/ambient.d.ts

@@ -0,0 +1,366 @@
+/**
+ * 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 PageData {}
+ *
+ * 	interface Platform {}
+ *
+ * 	interface PrivateEnv {}
+ *
+ * 	interface PublicEnv {}
+ * }
+ * ```
+ *
+ * By populating these interfaces, you will gain type safety when using `env`, `event.locals` and `event.platform`.
+ *
+ * Note that since it's an ambient declaration file, you have to be careful when using `import` statements. Once you add an `import`
+ * at the top level, the declaration file is no longer considered ambient and you lose access to these typings in other files.
+ * To avoid this, either use the `import(...)` function:
+ *
+ * ```ts
+ * interface Locals {
+ * 	user: import('$lib/types').User;
+ * }
+ * ```
+ * Or wrap the namespace with `declare global`:
+ * ```ts
+ * import { User } from '$lib/types';
+ *
+ * declare global {
+ * 	namespace App {
+ * 		interface Locals {
+ * 			user: User;
+ * 		}
+ * 		// ...
+ * 	}
+ * }
+ * ```
+ *
+ */
+declare namespace App {
+	/**
+	 * The interface that defines `event.locals`, which can be accessed in [hooks](https://kit.svelte.dev/docs/hooks) (`handle`, and `handleError`), server-only `load` functions, and `+server.js` files.
+	 */
+	export interface Locals {}
+
+	/**
+	 * Defines the common shape of the [$page.data store](https://kit.svelte.dev/docs/modules#$app-stores-page) - that is, the data that is shared between all pages.
+	 * The `Load` and `ServerLoad` functions in `./$types` will be narrowed accordingly.
+	 * Use optional properties for data that is only present on specific pages. Do not add an index signature (`[key: string]: any`).
+	 */
+	export interface PageData {}
+
+	/**
+	 * If your adapter provides [platform-specific context](https://kit.svelte.dev/docs/adapters#supported-environments-platform-specific-context) via `event.platform`, you can specify it here.
+	 */
+	export interface Platform {}
+
+	/**
+	 * The interface that defines the dynamic environment variables exported from `$env/dynamic/private`.
+	 */
+	export interface PrivateEnv extends Record<string, string> {}
+
+	/**
+	 * The interface that defines the dynamic environment variables exported from `$env/dynamic/public`.
+	 */
+	export interface PublicEnv extends Record<string, string> {}
+}
+
+/**
+ * ```ts
+ * import { browser, dev, prerendering } from '$app/env';
+ * ```
+ */
+declare module '$app/env' {
+	/**
+	 * `true` if the app is running in the browser.
+	 */
+	export const browser: boolean;
+
+	/**
+	 * Whether the dev server is running. This is not guaranteed to correspond to `NODE_ENV` or `MODE`.
+	 */
+	export const dev: boolean;
+
+	/**
+	 * `true` when prerendering, `false` otherwise.
+	 */
+	export const prerendering: boolean;
+}
+
+/**
+ * This module provides access to runtime environment variables, as defined by the platform you're running on. For example
+ * if you're using [`adapter-node`](https://github.com/sveltejs/kit/tree/master/packages/adapter-node) (or running
+ * [`vite preview`](https://kit.svelte.dev/docs/cli)), this is equivalent to `process.env`. This module only includes
+ * variables that _do not_ begin with [`config.kit.env.publicPrefix`](https://kit.svelte.dev/docs/configuration#kit-env-publicprefix).
+ *
+ * This module cannot be imported into client-side code.
+ *
+ * ```ts
+ * import { env } from '$env/dynamic/private';
+ * console.log(env.DEPLOYMENT_SPECIFIC_VARIABLE);
+ * ```
+ */
+declare module '$env/dynamic/private' {
+	export let env: App.PrivateEnv;
+}
+
+/**
+ * Similar to [`$env/dynamic/private`](https://kit.svelte.dev/docs/modules#$env-dynamic-private), but only includes
+ * variables that begin with [`config.kit.env.publicPrefix`](https://kit.svelte.dev/docs/configuration#kit-env-publicprefix)
+ * (which defaults to `PUBLIC_`), and can therefore safely be exposed to client-side code
+ *
+ * Note that public dynamic environment variables must all be sent from the server to the client, causing larger network requests — when possible, use `$env/static/public` instead.
+ *
+ * ```ts
+ * import { env } from '$env/dynamic/public';
+ * console.log(env.PUBLIC_DEPLOYMENT_SPECIFIC_VARIABLE);
+ * ```
+ */
+declare module '$env/dynamic/public' {
+	export let env: App.PublicEnv;
+}
+
+/**
+ * ```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 `url`.
+	 *
+	 * @param url 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(
+		url: string | URL,
+		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. If no argument is given, all resources will be invalidated. 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`](https://kit.svelte.dev/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`](https://kit.svelte.dev/docs/configuration#paths).
+	 *
+	 * > If a value for `config.kit.paths.assets` is specified, it will be replaced with `'/_svelte_kit_assets'` during `vite dev` or `vite preview`, since the assets don't yet live at their eventual URL.
+	 */
+	export const assets: `https://${string}` | `http://${string}`;
+}
+
+/**
+ * ```ts
+ * import { getStores, navigating, page, updated } from '$app/stores';
+ * ```
+ *
+ * Stores on the server are _contextual_ — they are added to the [context](https://svelte.dev/tutorial/context-api) of your root component. This means that `page` is unique to each request, rather than shared between multiple requests handled by the same server simultaneously.
+ *
+ * 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.
+ *
+ * In the browser, we don't need to worry about this, and stores can be accessed from anywhere. Code that will only ever run on the browser can refer to (or subscribe to) any of these stores at any time.
+ */
+declare module '$app/stores' {
+	import { Readable } from 'svelte/store';
+	import { Navigation, Page } from '@sveltejs/kit';
+
+	/**
+	 * 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 readable store whose initial value is `false`. If [`version.pollInterval`](https://kit.svelte.dev/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 };
+
+	/**
+	 * A function that returns all of the contextual stores. On the server, this 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;
+		updated: typeof updated;
+	};
+}
+
+/**
+ * ```ts
+ * import { build, files, prerendered, version } from '$service-worker';
+ * ```
+ *
+ * This module is only available to [service workers](https://kit.svelte.dev/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`](https://kit.svelte.dev/docs/configuration)
+	 */
+	export const files: string[];
+	/**
+	 * An array of pathnames corresponding to prerendered pages and endpoints.
+	 */
+	export const prerendered: string[];
+	/**
+	 * See [`config.kit.version`](https://kit.svelte.dev/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;
+}
+
+declare module '@sveltejs/kit/vite' {
+	import { Plugin } from 'vite';
+
+	/**
+	 * Returns the SvelteKit Vite plugins.
+	 */
+	export function sveltekit(): Plugin[];
+}

package/types/index.d.ts

@@ -0,0 +1,345 @@
+/// <reference types="svelte" />
+/// <reference types="vite/client" />
+
+import './ambient.js';
+
+import { CompileOptions } from 'svelte/types/compiler/interfaces';
+import {
+	AdapterEntry,
+	CspDirectives,
+	Logger,
+	MaybePromise,
+	Prerendered,
+	PrerenderOnErrorValue,
+	RequestOptions,
+	ResponseHeaders,
+	RouteDefinition,
+	TrailingSlash
+} from './private.js';
+import { SSRNodeLoader, SSRRoute, ValidatedConfig } from './internal.js';
+import { HttpError, Redirect } from '../src/index/private.js';
+
+export interface Adapter {
+	name: string;
+	adapt(builder: Builder): MaybePromise<void>;
+}
+
+export type AwaitedProperties<input extends Record<string, any> | void> = input extends void
+	? undefined // needs to be undefined, because void will break intellisense
+	: input extends Record<string, any>
+	? {
+			[key in keyof input]: Awaited<input[key]>;
+	  }
+	: {} extends input // handles the any case
+	? input
+	: unknown;
+
+export type AwaitedErrors<T extends (...args: any) => any> = Awaited<ReturnType<T>> extends {
+	errors?: any;
+}
+	? Awaited<ReturnType<T>>['errors']
+	: undefined;
+
+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[];
+
+	/**
+	 * @param {string} directory Path to the directory containing the files to be compressed
+	 */
+	compress(directory: string): void;
+}
+
+export interface Config {
+	compilerOptions?: CompileOptions;
+	extensions?: string[];
+	kit?: KitConfig;
+	package?: {
+		source?: string;
+		dir?: string;
+		emitTypes?: boolean;
+		exports?: (filepath: string) => boolean;
+		files?: (filepath: string) => boolean;
+	};
+	preprocess?: any;
+	[key: string]: 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;
+	};
+	env?: {
+		dir?: string;
+		publicPrefix?: string;
+	};
+	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;
+	paths?: {
+		assets?: string;
+		base?: string;
+	};
+	prerender?: {
+		concurrency?: number;
+		crawl?: boolean;
+		default?: boolean;
+		enabled?: boolean;
+		entries?: Array<'*' | `/${string}`>;
+		onError?: PrerenderOnErrorValue;
+		origin?: string;
+	};
+	serviceWorker?: {
+		register?: boolean;
+		files?: (filepath: string) => boolean;
+	};
+	trailingSlash?: TrailingSlash;
+	version?: {
+		name?: string;
+		pollInterval?: number;
+	};
+}
+
+export interface ExternalFetch {
+	(req: Request): Promise<Response>;
+}
+
+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 generic form of `PageLoad` and `LayoutLoad`. You should import those from `./$types` (see [generated types](https://kit.svelte.dev/docs/types#generated-types))
+ * rather than using `Load` directly.
+ */
+export interface Load<
+	Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,
+	InputData extends Record<string, unknown> | null = Record<string, any> | null,
+	ParentData extends Record<string, unknown> = Record<string, any>,
+	OutputData extends Record<string, unknown> | void = Record<string, any> | void
+> {
+	(event: LoadEvent<Params, InputData, ParentData>): MaybePromise<OutputData>;
+}
+
+export interface LoadEvent<
+	Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,
+	Data extends Record<string, unknown> | null = Record<string, any> | null,
+	ParentData extends Record<string, unknown> = Record<string, any>
+> {
+	fetch(info: RequestInfo, init?: RequestInit): Promise<Response>;
+	params: Params;
+	data: Data;
+	routeId: string | null;
+	setHeaders: (headers: ResponseHeaders) => void;
+	url: URL;
+	parent: () => Promise<ParentData>;
+	depends: (...deps: string[]) => void;
+}
+
+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;
+	status: number;
+	error: HttpError | Error | null;
+	data: App.PageData & Record<string, any>;
+}
+
+export interface ParamMatcher {
+	(param: string): boolean;
+}
+
+export interface RequestEvent<
+	Params extends Partial<Record<string, string>> = Partial<Record<string, string>>
+> {
+	getClientAddress: () => string;
+	locals: App.Locals;
+	params: Params;
+	platform: Readonly<App.Platform>;
+	request: Request;
+	routeId: string | null;
+	setHeaders: (headers: ResponseHeaders) => void;
+	url: URL;
+}
+
+/**
+ * A `(event: RequestEvent) => Response` function exported from a `+server.js` file 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.
+ */
+export interface RequestHandler<
+	Params extends Partial<Record<string, string>> = Partial<Record<string, string>>
+> {
+	(event: RequestEvent<Params>): MaybePromise<Response>;
+}
+
+export interface ResolveOptions {
+	ssr?: boolean;
+	transformPageChunk?: (input: { html: string; done: boolean }) => MaybePromise<string | undefined>;
+}
+
+export class Server {
+	constructor(manifest: SSRManifest);
+	init(options: ServerInitOptions): Promise<void>;
+	respond(request: Request, options: RequestOptions): Promise<Response>;
+}
+
+export interface ServerInitOptions {
+	env: Record<string, string>;
+}
+
+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>>;
+	};
+}
+
+/**
+ * The generic form of `PageServerLoad` and `LayoutServerLoad`. You should import those from `./$types` (see [generated types](https://kit.svelte.dev/docs/types#generated-types))
+ * rather than using `ServerLoad` directly.
+ */
+export interface ServerLoad<
+	Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,
+	ParentData extends Record<string, any> = Record<string, any>,
+	OutputData extends Record<string, any> | void = Record<string, any> | void
+> {
+	(event: ServerLoadEvent<Params, ParentData>): MaybePromise<OutputData>;
+}
+
+export interface ServerLoadEvent<
+	Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,
+	ParentData extends Record<string, any> = Record<string, any>
+> extends RequestEvent<Params> {
+	parent: () => Promise<ParentData>;
+}
+
+export interface Action<
+	Params extends Partial<Record<string, string>> = Partial<Record<string, string>>
+> {
+	(event: RequestEvent<Params>): MaybePromise<
+		| { status?: number; errors: Record<string, any>; location?: never }
+		| { status?: never; errors?: never; location: string }
+		| void
+	>;
+}
+
+// TODO figure out how to just re-export from '../src/index/index.js' without
+// breaking the site
+
+/**
+ * Creates an `HttpError` object with an HTTP status code and an optional message.
+ * This object, if thrown during request handling, will cause SvelteKit to
+ * return an error response without invoking `handleError`
+ * @param {number} status
+ * @param {string | undefined} [message]
+ */
+export function error(status: number, message?: string | undefined): HttpError;
+
+/**
+ * Creates a `Redirect` object. If thrown during request handling, SvelteKit will
+ * return a redirect response.
+ */
+export function redirect(status: number, location: string): Redirect;
+
+/**
+ * Generates a JSON `Response` object from the supplied data.
+ */
+export function json(data: any, init?: ResponseInit): Response;