Types
Edit this page on GitHubPublic types permalink
The following types can be imported from @sveltejs/kit
:
Action permalink
Shape of a form action method that is part of export const actions = {..}
in +page.server.js.ts
.
See form actions for more information.
ts
type Action<Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,OutputData extends Record<string, any> | void = Record<string, any> | void,RouteId extends string | null = string | null
ActionResult permalink
When calling a form action via fetch, the response will be one of these shapes.
<form method="post" use:enhance={() => {
return ({ result }) => {
// result is of type ActionResult };
}}
ts
type ActionResult<Success extends Record<string, unknown> | undefined = Record<string, any>,Failure extends Record<string, unknown> | undefined = Record<string, any>> =| { type: 'success'; status: number; data?: Success }| { type: 'failure'; status: number; data?: Failure }| { type: 'redirect'; status: number; location: string }| { type: 'error'; status?: number; error: any };
Actions permalink
Shape of the export const actions = {..}
object in +page.server.js.ts
.
See form actions for more information.
ts
type Actions<Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,OutputData extends Record<string, any> | void = Record<string, any> | void,RouteId extends string | null = string | null
Adapter permalink
Adapters are responsible for taking the production build and turning it into something that can be deployed to a platform of your choosing.
ts
interface Adapter {…}
ts
name: string;
The name of the adapter, using for logging. Will typically correspond to the package name.
ts
This function is called after SvelteKit has built your app.
AdapterEntry permalink
ts
interface AdapterEntry {…}
ts
id: string;
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
ts
filter(route: RouteDefinition): boolean;
A function that compares the candidate route with the current route to determine if it should be grouped with the current route.
Use cases:
- Fallback pages:
/foo/[c]
is a fallback for/foo/a-[b]
, and/[...catchall]
is a fallback for all routes - Grouping routes that share a common
config
:/foo
should be deployed to the edge,/bar
and/baz
should be deployed to a serverless function
ts
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.
AfterNavigate permalink
The argument passed to afterNavigate
callbacks.
ts
ts
The type of navigation:
enter
: The app has hydratedform
: The user submitted a<form>
link
: Navigation was triggered by a link clickgoto
: Navigation was triggered by agoto(...)
call or a redirectpopstate
: Navigation was triggered by back/forward navigation
ts
willUnload: false;
Since afterNavigate
is called after a navigation completes, it will never be called with a navigation that unloads the page.
AwaitedActions permalink
ts
type AwaitedActions<T extends Record<string, (...args: any) => any>> =OptionalUnion<{[Key in keyof T]: UnpackValidationError<Awaited<ReturnType<T[Key]>>>;}[keyof T]>;
AwaitedProperties permalink
ts
type AwaitedProperties<input extends Record<string, any> | void> =AwaitedPropertiesUnion<input> extends Record<string, any>? OptionalUnion<AwaitedPropertiesUnion<input>>: AwaitedPropertiesUnion<input>;
BeforeNavigate permalink
The argument passed to beforeNavigate
callbacks.
ts
ts
cancel(): void;
Call this to prevent the navigation from starting.
Builder permalink
This object is passed to the adapt
function of adapters.
It contains various methods and properties that are useful for adapting the app.
ts
interface Builder {…}
ts
Print messages to the console. log.info
and log.minor
are silent unless Vite's logLevel
is info
.
ts
rimraf(dir: string): void;
Remove dir
and all its contents.
ts
mkdirp(dir: string): void;
Create dir
and any required parent directories.
ts
config: ValidatedConfig;
The fully resolved svelte.config.js
.
ts
Information about prerendered pages and assets, if any.
ts
An array of all routes (including prerendered)
ts
Create separate functions that map to one or more routes of your app.
ts
generateFallback(dest: string): Promise<void>;
Generate a fallback page for a static webserver to use when no route is matched. Useful for single-page apps.
ts
Generate a server-side manifest to initialise the SvelteKit server with.
ts
getBuildDirectory(name: string): string;
Resolve a path to the name
directory inside outDir
, e.g. /path/to/.svelte-kit/my-adapter
.
ts
getClientDirectory(): string;
Get the fully resolved path to the directory containing client-side assets, including the contents of your static
directory.
ts
getServerDirectory(): string;
Get the fully resolved path to the directory containing server-side code.
ts
getAppPath(): string;
Get the application path including any configured base
path, e.g. /my-base-path/_app
.
ts
writeClient(dest: string): string[];
Write client assets to dest
.
ts
writePrerendered(dest: string): string[];
Write prerendered files to dest
.
ts
writeServer(dest: string): string[];
Write server-side code to dest
.
ts
copy(from: string,to: string,opts?: {filter?(basename: string): boolean;replace?: Record<string, string>;}): string[];
Copy a file or directory.
ts
compress(directory: string): Promise<void>;
Compress files in directory
with gzip and brotli, where appropriate. Generates .gz
and .br
files alongside the originals.
Config permalink
ts
interface Config {…}
See the configuration reference for details.
Cookies permalink
ts
interface Cookies {…}
ts
get(name: string, opts?: import('cookie').CookieParseOptions): string | undefined;
Gets a cookie that was previously set with cookies.set
, or from the request headers.
ts
getAll(opts?: import('cookie').CookieParseOptions): Array<{ name: string; value: string }>;
Gets all cookies that were previously set with cookies.set
, or from the request headers.
ts
set(name: string, value: string, opts?: import('cookie').CookieSerializeOptions): void;
Sets a cookie. This will add a set-cookie
header to the response, but also make the cookie available via cookies.get
or cookies.getAll
during the current request.
The httpOnly
and secure
options are true
by default (except on http://localhost, where secure
is false
), and must be explicitly disabled if you want cookies to be readable by client-side JavaScript and/or transmitted over HTTP. The sameSite
option defaults to lax
.
By default, the path
of a cookie is the 'directory' of the current pathname. In most cases you should explicitly set path: '/'
to make the cookie available throughout your app.
ts
delete(name: string, opts?: import('cookie').CookieSerializeOptions): void;
Deletes a cookie by setting its value to an empty string and setting the expiry date in the past.
By default, the path
of a cookie is the 'directory' of the current pathname. In most cases you should explicitly set path: '/'
to make the cookie available throughout your app.
ts
serialize(name: string, value: string, opts?: import('cookie').CookieSerializeOptions): string;
Serialize a cookie name-value pair into a Set-Cookie
header string, but don't apply it to the response.
The httpOnly
and secure
options are true
by default (except on http://localhost, where secure
is false
), and must be explicitly disabled if you want cookies to be readable by client-side JavaScript and/or transmitted over HTTP. The sameSite
option defaults to lax
.
By default, the path
of a cookie is the current pathname. In most cases you should explicitly set path: '/'
to make the cookie available throughout your app.
Csp permalink
ts
namespace Csp {type ActionSource = 'strict-dynamic' | 'report-sample';type BaseSource =| 'self'| 'unsafe-eval'| 'unsafe-hashes'| 'unsafe-inline'| 'wasm-unsafe-eval'| '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}`;}
CspDirectives permalink
ts
interface CspDirectives {…}
ts
ts
ts
ts
ts
ts
ts
ts
ts
ts
ts
ts
ts
ts
ts
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'>;
ts
ts
'report-to'?: string[];
ts
'require-trusted-types-for'?: Array<'script'>;
ts
'trusted-types'?: Array<'none' | 'allow-duplicates' | '*' | string>;
ts
'upgrade-insecure-requests'?: boolean;
ts
'require-sri-for'?: Array<'script' | 'style' | 'script style'>;
ts
'block-all-mixed-content'?: boolean;
ts
'plugin-types'?: Array<`${string}/${string}` | 'none'>;
ts
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'>;
Handle permalink
The handle
hook runs every time the SvelteKit server receives a request and
determines the response.
It receives an event
object representing the request and a function called resolve
, which renders the route and generates a Response
.
This allows you to modify response headers or bodies, or bypass SvelteKit entirely (for implementing routes programmatically, for example).
ts
type Handle = (input: {
HandleClientError permalink
The client-side handleError
hook runs when an unexpected error is thrown while navigating.
If an unexpected error is thrown during loading or the following render, this function will be called with the error and the event. Make sure that this function never throws an error.
ts
type HandleClientError = (input: {error: unknown;
HandleFetch permalink
The handleFetch
hook allows you to modify (or replace) a fetch
request that happens inside a load
function that runs on the server (or during pre-rendering)
ts
type HandleFetch = (input: {request: Request;fetch: typeof fetch;
HandleServerError permalink
The server-side handleError
hook runs when an unexpected error is thrown while responding to a request.
If an unexpected error is thrown during loading or rendering, this function will be called with the error and the event. Make sure that this function never throws an error.
ts
type HandleServerError = (input: {error: unknown;
HttpError permalink
The object returned by the error
function.
ts
interface HttpError {…}
ts
status: number;
The HTTP status code, in the range 400-599.
ts
The content of the error.
HttpError permalink
ts
HttpMethod permalink
ts
type HttpMethod =| 'GET'| 'HEAD'| 'POST'| 'PUT'| 'DELETE'| 'PATCH'| 'OPTIONS';
KitConfig permalink
ts
interface KitConfig {…}
See the configuration reference for details.
Load permalink
The generic form of PageLoad
and LayoutLoad
. You should import those from ./$types
(see generated types)
rather than using Load
directly.
ts
type 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,RouteId extends string | null = string | null> = (
LoadEvent permalink
The generic form of PageLoadEvent
and LayoutLoadEvent
. You should import those from ./$types
(see generated types)
rather than using LoadEvent
directly.
ts
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>,RouteId extends string | null = string | null
ts
fetch: typeof fetch;
fetch
is equivalent to the native fetch
web API, with a few additional features:
- it can be used to make credentialed requests on the server, as it inherits the
cookie
andauthorization
headers for the page request - it can make relative requests on the server (ordinarily,
fetch
requires a URL with an origin when used in a server context) - internal requests (e.g. for
+server.js.ts
routes) go directly to the handler function when running on the server, without the overhead of an HTTP call - during server-side rendering, the response will be captured and inlined into the rendered HTML. Note that headers will not be serialized, unless explicitly included via
filterSerializedResponseHeaders
- during hydration, the response will be read from the HTML, guaranteeing consistency and preventing an additional network request
Cookies will only be passed through if the target host is the same as the SvelteKit application or a more specific subdomain of it.
ts
data: Data;
Contains the data returned by the route's server load
function (in +layout.server.js.ts
or +page.server.js.ts
), if any.
ts
setHeaders(headers: Record<string, string>): void;
If you need to set headers for the response, you can do so using the this method. This is useful if you want the page to be cached, for example:
ts
export async functionBinding element 'fetch' implicitly has an 'any' type.Binding element 'setHeaders' implicitly has an 'any' type.7031load ({, fetch }) { setHeaders
7031Binding element 'fetch' implicitly has an 'any' type.Binding element 'setHeaders' implicitly has an 'any' type.consturl = `https://cms.example.com/articles.json`;constresponse = awaitfetch (url );setHeaders ({age :response .headers .get ('age'),'cache-control':response .headers .get ('cache-control')});returnresponse .json ();}
Setting the same header multiple times (even in separate load
functions) is an error — you can only set a given header once.
You cannot add a set-cookie
header with setHeaders
— use the cookies
API in a server-only load
function instead.
setHeaders
has no effect when a load
function runs in the browser.
ts
parent(): Promise<ParentData>;
await parent()
returns data from parent +layout.js.ts
load
functions.
Implicitly, a missing +layout.js.ts
is treated as a ({ data }) => data
function, meaning that it will return and forward data from parent +layout.server.js.ts
files.
Be careful not to introduce accidental waterfalls when using await parent()
. If for example you only want to merge parent data into the returned output, call it after fetching your other data.
ts
depends(...deps: string[]): void;
This function declares that the load
function has a dependency on one or more URLs or custom identifiers, which can subsequently be used with invalidate()
to cause load
to rerun.
Most of the time you won't need this, as fetch
calls depends
on your behalf — it's only necessary if you're using a custom API client that bypasses fetch
.
URLs can be absolute or relative to the page being loaded, and must be encoded.
Custom identifiers have to be prefixed with one or more lowercase letters followed by a colon to conform to the URI specification.
The following example shows how to use depends
to register a dependency on a custom identifier, which is invalidate
d after a button click, making the load
function rerun.
ts
letcount = 0;export async functionBinding element 'depends' implicitly has an 'any' type.7031Binding element 'depends' implicitly has an 'any' type.load ({}) { depends depends ('increase:count');return {count :count ++ };}
<script>
import { invalidate } from '$app/navigation';
export let data;
const increase = async () => {
await invalidate('increase:count');
}
</script>
<p>{data.count}<p>
<button on:click={increase}>Increase Count</button>
Logger permalink
ts
interface Logger {…}
ts
(msg: string): void;
ts
success(msg: string): void;
ts
error(msg: string): void;
ts
warn(msg: string): void;
ts
minor(msg: string): void;
ts
info(msg: string): void;
MaybePromise permalink
ts
type MaybePromise<T> = T | Promise<T>;
Navigation permalink
ts
interface Navigation {…}
ts
Where navigation was triggered from
ts
Where navigation is going to/has gone to
ts
The type of navigation:
form
: The user submitted a<form>
leave
: The user is leaving the app by closing the tab or using the back/forward buttons to go to a different documentlink
: Navigation was triggered by a link clickgoto
: Navigation was triggered by agoto(...)
call or a redirectpopstate
: Navigation was triggered by back/forward navigation
ts
willUnload: boolean;
Whether or not the navigation will result in the page being unloaded (i.e. not a client-side navigation)
ts
delta?: number;
In case of a history back/forward navigation, the number of steps to go back/forward
NavigationEvent permalink
ts
interface NavigationEvent<Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,RouteId extends string | null = string | null> {…}
ts
params: Params;
The parameters of the current page - e.g. for a route like /blog/[slug]
, a { slug: string }
object
ts
route: {…}
Info about the current route
ts
id: RouteId;
The ID of the current route - e.g. for src/routes/blog/[slug]
, it would be /blog/[slug]
ts
url: URL;
The URL of the current page
NavigationTarget permalink
Information about the target of a specific navigation.
ts
interface NavigationTarget {…}
ts
params: Record<string, string> | null;
Parameters of the target page - e.g. for a route like /blog/[slug]
, a { slug: string }
object.
Is null
if the target is not part of the SvelteKit app (could not be resolved to a route).
ts
route: { id: string | null };
Info about the target route
ts
url: URL;
The URL that is navigated to
NavigationType permalink
enter
: The app has hydratedform
: The user submitted a<form>
leave
: The user is leaving the app by closing the tab or using the back/forward buttons to go to a different documentlink
: Navigation was triggered by a link clickgoto
: Navigation was triggered by agoto(...)
call or a redirectpopstate
: Navigation was triggered by back/forward navigation
ts
type NavigationType = 'enter' | 'form' | 'leave' | 'link' | 'goto' | 'popstate';
Page permalink
The shape of the $page
store
ts
interface Page<Params extends Record<string, string> = Record<string, string>,RouteId extends string | null = string | null> {…}
ts
url: URL;
The URL of the current page
ts
params: Params;
The parameters of the current page - e.g. for a route like /blog/[slug]
, a { slug: string }
object
ts
route: {…}
Info about the current route
ts
id: RouteId;
The ID of the current route - e.g. for src/routes/blog/[slug]
, it would be /blog/[slug]
ts
status: number;
Http status code of the current page
ts
The error object of the current page, if any. Filled from the handleError
hooks.
ts
The merged result of all data from all load
functions on the current page. You can type a common denominator through App.PageData
.
ts
form: any;
Filled only after a form submission. See form actions for more info.
ParamMatcher permalink
The shape of a param matcher. See matching for more info.
ts
type ParamMatcher = (param: string) => boolean;
PrerenderEntryGeneratorMismatchHandler permalink
ts
interface PrerenderEntryGeneratorMismatchHandler {…}
ts
(details: { generatedFromId: string; entry: string; matchedId: string; message: string }): void;
PrerenderEntryGeneratorMismatchHandlerValue permalink
ts
type PrerenderEntryGeneratorMismatchHandlerValue =| 'fail'| 'warn'| 'ignore'
PrerenderHttpErrorHandler permalink
ts
interface PrerenderHttpErrorHandler {…}
ts
(details: {status: number;path: string;referrer: string | null;referenceType: 'linked' | 'fetched';message: string;}): void;
PrerenderHttpErrorHandlerValue permalink
ts
type PrerenderHttpErrorHandlerValue =| 'fail'| 'warn'| 'ignore'
PrerenderMap permalink
ts
PrerenderMissingIdHandler permalink
ts
interface PrerenderMissingIdHandler {…}
ts
(details: { path: string; id: string; referrers: string[]; message: string }): void;
PrerenderMissingIdHandlerValue permalink
ts
type PrerenderMissingIdHandlerValue =| 'fail'| 'warn'| 'ignore'
PrerenderOption permalink
ts
type PrerenderOption = boolean | 'auto';
Prerendered permalink
ts
interface Prerendered {…}
ts
pages: Map<string,{/** The location of the .html file relative to the output directory */file: string;}>;
A map of path
to { file }
objects, where a path like /foo
corresponds to foo.html
and a path like /bar/
corresponds to bar/index.html
.
ts
assets: Map<string,{/** The MIME type of the asset */type: string;}>;
A map of path
to { type }
objects.
ts
redirects: Map<string,{status: number;location: string;}>;
A map of redirects encountered during prerendering.
ts
paths: string[];
An array of prerendered paths (without trailing slashes, regardless of the trailingSlash config)
Redirect permalink
The object returned by the redirect
function
ts
interface Redirect {…}
ts
status: 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308;
The HTTP status code, in the range 300-308.
ts
location: string;
The location to redirect to.
Redirect permalink
ts
class Redirect {constructor(status: 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308,location: string);status: 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308;location: string;}
RequestEvent permalink
ts
interface RequestEvent<Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,RouteId extends string | null = string | null> {…}
ts
Get or set cookies related to the current request
ts
fetch: typeof fetch;
fetch
is equivalent to the native fetch
web API, with a few additional features:
- it can be used to make credentialed requests on the server, as it inherits the
cookie
andauthorization
headers for the page request - it can make relative requests on the server (ordinarily,
fetch
requires a URL with an origin when used in a server context) - internal requests (e.g. for
+server.js.ts
routes) go directly to the handler function when running on the server, without the overhead of an HTTP call
Cookies will only be passed through if the target host is the same as the SvelteKit application or a more specific subdomain of it.
ts
getClientAddress(): string;
The client's IP address, set by the adapter.
ts
Contains custom data that was added to the request within the handle hook
.
ts
params: Params;
The parameters of the current route - e.g. for a route like /blog/[slug]
, a { slug: string }
object
ts
Additional data made available through the adapter.
ts
request: Request;
The original request object
ts
route: {…}
Info about the current route
ts
id: RouteId;
The ID of the current route - e.g. for src/routes/blog/[slug]
, it would be /blog/[slug]
ts
setHeaders(headers: Record<string, string>): void;
If you need to set headers for the response, you can do so using the this method. This is useful if you want the page to be cached, for example:
ts
export async functionBinding element 'fetch' implicitly has an 'any' type.Binding element 'setHeaders' implicitly has an 'any' type.7031load ({, fetch }) { setHeaders
7031Binding element 'fetch' implicitly has an 'any' type.Binding element 'setHeaders' implicitly has an 'any' type.consturl = `https://cms.example.com/articles.json`;constresponse = awaitfetch (url );setHeaders ({age :response .headers .get ('age'),'cache-control':response .headers .get ('cache-control')});returnresponse .json ();}
Setting the same header multiple times (even in separate load
functions) is an error — you can only set a given header once.
You cannot add a set-cookie
header with setHeaders
— use the cookies
API instead.
ts
url: URL;
The requested URL.
ts
isDataRequest: boolean;
true
if the request comes from the client asking for +page/layout.server.js.ts
data. The url
property will be stripped of the internal information
related to the data request in this case. Use this property instead if the distinction is important to you.
RequestHandler permalink
A (event: RequestEvent) => Response
function exported from a +server.js.ts
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 instead.
ts
type RequestHandler<Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,RouteId extends string | null = string | null
RequestOptions permalink
ResolveOptions permalink
ts
interface ResolveOptions {…}
ts
Applies custom transforms to HTML. If done
is true, it's the final chunk. Chunks are not guaranteed to be well-formed HTML
(they could include an element's opening tag but not its closing tag, for example)
but they will always be split at sensible boundaries such as %sveltekit.head%
or layout/page components.
ts
filterSerializedResponseHeaders?(name: string, value: string): boolean;
Determines which headers should be included in serialized responses when a load
function loads a resource with fetch
.
By default, none will be included.
ts
preload?(input: { type: 'font' | 'css' | 'js' | 'asset'; path: string }): boolean;
Determines what should be added to the <head>
tag to preload it.
By default, js
, css
and font
files will be preloaded.
RouteDefinition permalink
ts
ts
id: string;
ts
api: {};
ts
page: {};
ts
pattern: RegExp;
ts
ts
ts
ts
RouteSegment permalink
ts
interface RouteSegment {…}
ts
content: string;
ts
dynamic: boolean;
ts
rest: boolean;
SSRManifest permalink
ts
interface SSRManifest {…}
ts
appDir: string;
ts
appPath: string;
ts
assets: Set<string>;
ts
mimeTypes: Record<string, string>;
ts
_: {client: NonNullable<BuildData['client']>;nodes: SSRNodeLoader[];routes: SSRRoute[];};
private fields
Server permalink
ts
class Server {}
ServerInitOptions permalink
ts
interface ServerInitOptions {…}
ts
env: Record<string, string>;
ServerLoad permalink
The generic form of PageServerLoad
and LayoutServerLoad
. You should import those from ./$types
(see generated types)
rather than using ServerLoad
directly.
ts
type 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,RouteId extends string | null = string | null> = (
ServerLoadEvent permalink
ts
interface ServerLoadEvent<Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,ParentData extends Record<string, any> = Record<string, any>,RouteId extends string | null = string | null
ts
parent(): Promise<ParentData>;
await parent()
returns data from parent +layout.server.js.ts
load
functions.
Be careful not to introduce accidental waterfalls when using await parent()
. If for example you only want to merge parent data into the returned output, call it after fetching your other data.
ts
depends(...deps: string[]): void;
This function declares that the load
function has a dependency on one or more URLs or custom identifiers, which can subsequently be used with invalidate()
to cause load
to rerun.
Most of the time you won't need this, as fetch
calls depends
on your behalf — it's only necessary if you're using a custom API client that bypasses fetch
.
URLs can be absolute or relative to the page being loaded, and must be encoded.
Custom identifiers have to be prefixed with one or more lowercase letters followed by a colon to conform to the URI specification.
The following example shows how to use depends
to register a dependency on a custom identifier, which is invalidate
d after a button click, making the load
function rerun.
ts
letcount = 0;export async functionBinding element 'depends' implicitly has an 'any' type.7031Binding element 'depends' implicitly has an 'any' type.load ({}) { depends depends ('increase:count');return {count :count ++ };}
<script>
import { invalidate } from '$app/navigation';
export let data;
const increase = async () => {
await invalidate('increase:count');
}
</script>
<p>{data.count}<p>
<button on:click={increase}>Increase Count</button>
Snapshot permalink
The type of export const snapshot
exported from a page or layout component.
ts
interface Snapshot<T = any> {…}
ts
capture: () => T;
ts
restore: (snapshot: T) => void;
SubmitFunction permalink
ts
type SubmitFunction<Success extends Record<string, unknown> | undefined = Record<string, any>,Failure extends Record<string, unknown> | undefined = Record<string, any>> = (input: {action: URL;/*** use `formData` instead of `data`* */data: FormData;formData: FormData;/*** use `formElement` instead of `form`* */form: HTMLFormElement;formElement: HTMLFormElement;controller: AbortController;submitter: HTMLElement | null;cancel(): void;| void| ((opts: {/*** use `formData` instead of `data`* */data: FormData;formData: FormData;/*** use `formElement` instead of `form`* */form: HTMLFormElement;formElement: HTMLFormElement;action: URL;/*** Call this to get the default behavior of a form submission response.* */update(options?: { reset: boolean }): Promise<void>;}) => void)>;
TrailingSlash permalink
ts
type TrailingSlash = 'never' | 'always' | 'ignore';
Private types permalink
The following are referenced by the public types documented above, but cannot be imported directly:
AdapterEntry permalink
ts
interface AdapterEntry {…}
ts
id: string;
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
ts
filter(route: RouteDefinition): boolean;
A function that compares the candidate route with the current route to determine if it should be grouped with the current route.
Use cases:
- Fallback pages:
/foo/[c]
is a fallback for/foo/a-[b]
, and/[...catchall]
is a fallback for all routes - Grouping routes that share a common
config
:/foo
should be deployed to the edge,/bar
and/baz
should be deployed to a serverless function
ts
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.
Csp permalink
ts
namespace Csp {type ActionSource = 'strict-dynamic' | 'report-sample';type BaseSource =| 'self'| 'unsafe-eval'| 'unsafe-hashes'| 'unsafe-inline'| 'wasm-unsafe-eval'| '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}`;}
CspDirectives permalink
ts
interface CspDirectives {…}
ts
ts
ts
ts
ts
ts
ts
ts
ts
ts
ts
ts
ts
ts
ts
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'>;
ts
ts
'report-to'?: string[];
ts
'require-trusted-types-for'?: Array<'script'>;
ts
'trusted-types'?: Array<'none' | 'allow-duplicates' | '*' | string>;
ts
'upgrade-insecure-requests'?: boolean;
ts
'require-sri-for'?: Array<'script' | 'style' | 'script style'>;
ts
'block-all-mixed-content'?: boolean;
ts
'plugin-types'?: Array<`${string}/${string}` | 'none'>;
ts
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'>;
HttpMethod permalink
ts
type HttpMethod =| 'GET'| 'HEAD'| 'POST'| 'PUT'| 'DELETE'| 'PATCH'| 'OPTIONS';
Logger permalink
ts
interface Logger {…}
ts
(msg: string): void;
ts
success(msg: string): void;
ts
error(msg: string): void;
ts
warn(msg: string): void;
ts
minor(msg: string): void;
ts
info(msg: string): void;
MaybePromise permalink
ts
type MaybePromise<T> = T | Promise<T>;
PrerenderEntryGeneratorMismatchHandler permalink
ts
interface PrerenderEntryGeneratorMismatchHandler {…}
ts
(details: { generatedFromId: string; entry: string; matchedId: string; message: string }): void;
PrerenderEntryGeneratorMismatchHandlerValue permalink
ts
type PrerenderEntryGeneratorMismatchHandlerValue =| 'fail'| 'warn'| 'ignore'
PrerenderHttpErrorHandler permalink
ts
interface PrerenderHttpErrorHandler {…}
ts
(details: {status: number;path: string;referrer: string | null;referenceType: 'linked' | 'fetched';message: string;}): void;
PrerenderHttpErrorHandlerValue permalink
ts
type PrerenderHttpErrorHandlerValue =| 'fail'| 'warn'| 'ignore'
PrerenderMap permalink
ts
PrerenderMissingIdHandler permalink
ts
interface PrerenderMissingIdHandler {…}
ts
(details: { path: string; id: string; referrers: string[]; message: string }): void;
PrerenderMissingIdHandlerValue permalink
ts
type PrerenderMissingIdHandlerValue =| 'fail'| 'warn'| 'ignore'
PrerenderOption permalink
ts
type PrerenderOption = boolean | 'auto';
Prerendered permalink
ts
interface Prerendered {…}
ts
pages: Map<string,{/** The location of the .html file relative to the output directory */file: string;}>;
A map of path
to { file }
objects, where a path like /foo
corresponds to foo.html
and a path like /bar/
corresponds to bar/index.html
.
ts
assets: Map<string,{/** The MIME type of the asset */type: string;}>;
A map of path
to { type }
objects.
ts
redirects: Map<string,{status: number;location: string;}>;
A map of redirects encountered during prerendering.
ts
paths: string[];
An array of prerendered paths (without trailing slashes, regardless of the trailingSlash config)
RequestOptions permalink
RouteSegment permalink
ts
interface RouteSegment {…}
ts
content: string;
ts
dynamic: boolean;
ts
rest: boolean;
TrailingSlash permalink
ts
type TrailingSlash = 'never' | 'always' | 'ignore';
Generated types permalink
The RequestHandler
and Load
types both accept a Params
argument allowing you to type the params
object. For example this endpoint expects foo
, bar
and baz
params:
ts
* foo: string;* bar: string;* baz: string* }>} */export async functionA function whose declared type is neither 'void' nor 'any' must return a value.2355A function whose declared type is neither 'void' nor 'any' must return a value.({ GET params }) {// ...}
ts
export constGET = (async ({params }) => {// ...Type '({ params }: RequestEvent<{ foo: string; bar: string; baz: string; }, string | null>) => Promise<void>' does not satisfy the expected type 'RequestHandler<{ foo: string; bar: string; baz: string; }, string | null>'. Type 'Promise<void>' is not assignable to type 'MaybePromise<Response>'. Type 'Promise<void>' is not assignable to type 'Promise<Response>'. Type 'void' is not assignable to type 'Response'.1360Type '({ params }: RequestEvent<{ foo: string; bar: string; baz: string; }, string | null>) => Promise<void>' does not satisfy the expected type 'RequestHandler<{ foo: string; bar: string; baz: string; }, string | null>'. Type 'Promise<void>' is not assignable to type 'MaybePromise<Response>'. Type 'Promise<void>' is not assignable to type 'Promise<Response>'. Type 'void' is not assignable to type 'Response'.foo : string;bar : string;baz : string}>;
Needless to say, this is cumbersome to write out, and less portable (if you were to rename the [foo]
directory to [qux]
, the type would no longer reflect reality).
To solve this problem, SvelteKit generates .d.ts
files for each of your endpoints and pages:
ts
import type * asKit from '@sveltejs/kit';typeRouteParams = {foo : string;bar : string;baz : string;}export typePageServerLoad =Kit .ServerLoad <RouteParams >;export typePageLoad =Kit .Load <RouteParams >;
These files can be imported into your endpoints and pages as siblings, thanks to the rootDirs
option in your TypeScript configuration:
ts
/** @type {import('./$types').PageServerLoad} */export async functionGET ({params }) {// ...}
ts
import type {PageServerLoad } from './$types';export constGET = (async ({params }) => {// ...}) satisfiesPageServerLoad ;
ts
/** @type {import('./$types').PageLoad} */export async functionload ({params ,fetch }) {// ...}
ts
import type {PageLoad } from './$types';export constload = (async ({params ,fetch }) => {// ...}) satisfiesPageLoad ;
For this to work, your own
tsconfig.json
orjsconfig.json
should extend from the generated.svelte-kit/tsconfig.json
(where.svelte-kit
is youroutDir
):{ "extends": "./.svelte-kit/tsconfig.json" }
Default tsconfig.json permalink
The generated .svelte-kit/tsconfig.json
file contains a mixture of options. Some are generated programmatically based on your project configuration, and should generally not be overridden without good reason:
{
"compilerOptions": {
"baseUrl": "..",
"paths": {
"$lib": "src/lib",
"$lib/*": "src/lib/*"
},
"rootDirs": ["..", "./types"]
},
"include": ["../src/**/*.js", "../src/**/*.ts", "../src/**/*.svelte"],
"exclude": ["../node_modules/**", "./**"]
}
Others are required for SvelteKit to work properly, and should also be left untouched unless you know what you're doing:
{
"compilerOptions": {
// this ensures that types are explicitly
// imported with `import type`, which is
// necessary as svelte-preprocess cannot
// otherwise compile components correctly
"importsNotUsedAsValues": "error",
// Vite compiles one TypeScript module
// at a time, rather than compiling
// the entire module graph
"isolatedModules": true,
// TypeScript cannot 'see' when you
// use an imported value in your
// markup, so we need this
"preserveValueImports": true,
// This ensures both `vite build`
// and `svelte-package` work correctly
"lib": ["esnext", "DOM", "DOM.Iterable"],
"moduleResolution": "node",
"module": "esnext",
"target": "esnext"
}
}
App permalink
Error permalink
Defines the common shape of expected and unexpected errors. Expected errors are thrown using the error
function. Unexpected errors are handled by the handleError
hooks which should return this shape.
ts
interface Error {…}
ts
message: string;
Locals permalink
The interface that defines event.locals
, which can be accessed in hooks (handle
, and handleError
), server-only load
functions, and +server.js.ts
files.
ts
interface Locals {}
PageData permalink
Defines the common shape of the $page.data store - 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
).
ts
interface PageData {}
Platform permalink
If your adapter provides platform-specific context via event.platform
, you can specify it here.
ts
interface Platform {}