kit-monorepo (master)

# commands()

# default()

# get_adapter()

# import_from_cwd(name)

Parameters

# module()

# fetch(req, env, context)

Parameters

# get_asset_from_kv(req, env, context)

Parameters

# is_error(status)

Parameters

# res()

# validate_config(builder, config_file)

Parameters

# wrangler.toml()

# function()

# generate_headers(app_dir)

Parameters

# get_routes_json(builder, assets, routes)

Parameters

# worker()

# edge_manifest()

# files()

# function()

# generate_edge_functions(params, params.builder)

Parameters

# generate_lambda_functions(params, params.builder, params.publish, params.split)

Parameters

# matches(a, b)

Parameters

# config()

# handler(request, context)

Parameters

# is_static_file(request)

Parameters

# h()

# m()

# split_headers(headers)

Splits headers into two categories: single value and multi value

Parameters

# init(manifest)

Parameters

# init()

# is_text(content_type)

Decides how the body should be parsed based on its mime type

Parameters

# to_request(event)

Parameters

# req()

The original Node request object (https://nodejs.org/api/http.html#class-httpincomingmessage)

# function()

# env(name, fallback)

Parameters

# get_origin(headers)

Parameters

# handle(i)

Parameters

# return()

# sequence(handlers)

Parameters

# serve(path, client)

Parameters

# serve_prerendered()

# ssr()

# is()

# overrides()

# platforms()

# prerendered_redirects()

# static_vercel_config(builder)

Parameters

# load()

# GET()

# GET()

# config()

# config()

# config()

# config()

# config()

# ync(req, res)

Parameters

# expiration()

Expiration time (in seconds) before the cached asset will be re-generated by invoking the Serverless Function. Setting the value to false means it will never expire.

# nodejs16.x()

Whether to use Edge Functions or Serverless Functions

# sToken()

Random token that can be provided in the URL to bypass the cached version of the asset, by requesting the asset with a __prerender_bypass= cookie. Making a GET or HEAD request with x-prerender-revalidate: <token> will force the asset to be re-validated.

# common_parts()

# conflicts()

# counterpart_route()

# create_function_bundle(builder, entry, dir, config)

Parameters

# functions()

# generate_edge_function(name, config, routes)

Parameters

# generate_serverless_function()

# groups()

# hash_config(config)

Parameters

# is_prerendered(route)

Parameters

# isr_config()

# overrides()

# prerendered_redirects()

# static_vercel_config(builder)

Parameters

# unmatched_paths()

# valid_routes()

For a route to be considered 'valid', it must be an API route with a GET handler

# write(file, data)

Parameters

# get_pathname(route)

Parameters

# transform(html)

Parameters

# create()

# matches_condition(condition, options)

Parameters

# merge(target, source)

Parameters

# sort_files(files)

Sort files so that those which apply more generically come first so they can be overwritten by files for more precise cases later.

Parameters

# sort_keys(obj)

Parameters

# sorted()

# to_valid_package_name(name)

Parameters

# convert_typescript(content)

Parameters

# exclude()

# files()

# generate_templates(shared)

Parameters

# include()

# shared()

# strip_jsdoc(content)

Parameters

# types()

# config()

# config()

# config()

# config()

# config()

# config()

# actions()

# game.answers()

An array of strings like '__x_c' corresponding to the guesses, where 'x' means an exact match, and 'c' means a close match (right letter, wrong place)

# game.answers.length()

The correct answer, revealed if the game is over

# game.guesses()

The player's guessed words so far

# load()

# update()

Modify game state in reaction to a keypress. If client-side JavaScript is available, this will happen in the browser instead of here

# enter(letters)

Update game state based on a guess of a five-letter word. Returns true if the guess was valid, false otherwise

Parameters

# toString()

Serialize game state so it can be set as a cookie

# set_reduced_motion(event)

Parameters

# allowed()

The list of valid guesses, of which the list of possible words is a subset

# words()

The list of possible words

# config()

# config()

# config()

# patch_package_json(pkg)

Parameters

# resolve_path(path)

Resolve the given path relative to the current file

Parameters

# create(cwd, options)

Create a new SvelteKit project.

Parameters

# copy(from, to, rename)

Parameters

# dist(path)

Parameters

# identity(x)

Parameters

# mkdirp(dir)

Parameters

# rimraf(path)

Parameters

# handle_error(e)

Parameters

# SVELTE_KIT_ASSETS()

A fake asset path used in vite dev and vite preview, so that we can serve local assets while verifying that requests are correctly prefixed

# compress_file(file, format)

Parameters

# create_builder(opts)

Creates the Builder which is passed to adapters for building the application.

Parameters

# lookup()

# adapt(config, build_data, server_metadata, prerendered, prerender_map, log)

Parameters

# load_config(options)

Loads and validates svelte.config.js

Parameters

# load_error_page(config)

Loads the error page (src/error.html by default) if it exists. Falls back to a generic error page content.

Parameters

# load_template(cwd, config)

Loads the template (src/app.html by default) and validates that it has the required content.

Parameters

# process_config(config)

Parameters

# validate_config(config)

Parameters

# remove_keys(o, check)

mutates and remove keys from an object when check callback returns true

Parameters

# validate_paths(name, input, output)

Parameters

# assert_string(input, keypath)

Parameters

# boolean(fallback)

Parameters

# directives()

# fun(fallback)

Parameters

# list(options)

Parameters

# number(fallback)

Parameters

# object(children, allow_unknown)

Parameters

# options()

# output()

# string(fallback, allow_empty)

Parameters

# string_array(fallback)

Parameters

# validate(fallback, fn)

Parameters

# create_dynamic_module(type, dev_values)

Parameters

# create_dynamic_types(id, env, prefix)

Parameters

# create_static_module(id, env)

Parameters

# create_static_types(id, env)

Parameters

# declarations()

# generate_manifest(opts)

Generates the data used to write the server-side manifest.js file. This data is used in the Vite build process, to power routing, etc.

Parameters

# get_nodes(indexes)

Parameters

# loader()

# reindexed()

# used_nodes()

All nodes actually used in the routes definition (prerendered routes are omitted). Root layout/error is always included as they are needed for 404 and root errors.

# analyse(opts)

Parameters

# api_methods()

# config()

# config()

# entries()

# get_config(nodes)

Do a shallow merge (first level) of the config object

Parameters

# internal()

# manifest()

# metadata()

# page_methods()

# prerender()

# attributes()

# crawl(html, base)

Parameters

# hrefs()

# ids()

# decode(str)

Parameters

# entities()

A list of all named HTML entities, from https://html.spec.whatwg.org/multipage/named-characters.html

# config()

# generate_fallback(opts)

Parameters

# index.js()

# internal.js()

# manifest()

# actual_hashlinks()

# config()

# enqueue(referrer, decoded, encoded, generated_from_id)

Parameters

# expected_hashlinks()

# index.js()

# internal()

# log()

# manifest()

# normalise_error_handler(log, input, format)

Parameters

# not_prerendered()

# output_filename(path, is_html)

Parameters

# prerender(opts)

Parameters

# prerender_map()

# prerendered()

# prerendered_routes()

# route_level_entries()

# save(category, response, body, decoded, encoded, referrer, referenceType)

Parameters

# saved()

# visit(decoded, encoded, referrer, generated_from_id)

Parameters

# add(fn)

Parameters

# fulfil()

# queue(concurrency)

Parameters

# reject()

# tasks()

# fulfils()

# sleep(ms)

Parameters

# analyze(project_relative, file, component_extensions, module_extensions)

Parameters

# count_occurrences(needle, haystack)

Parameters

# create_assets(config)

Parameters

# create_manifest_data(opts)

Generates the manifest data used for the client-side manifest and types generation.

Parameters

# create_matchers(config, cwd)

Parameters

# create_routes_and_nodes(config, cwd, fallback)

Parameters

# files()

# list_files(dir)

Parameters

# matchers()

# nodes()

# normalize_route_id(id)

Parameters

# prevent_conflicts(routes)

Parameters

# route()

# routes()

# walk(depth, id, segment, parent)

Parameters

# walk(current)

Parameters

# simplified()

# simplify_node(node)

Parameters

# simplify_route(route)

Parameters

# EMPTY()

# get_parts(segment)

Parameters

# parts()

# segment_cache()

# sort_routes(routes)

Parameters

# sort_static(a, b)

Sort two strings lexicographically, except foobar outranks foo

Parameters

# split(id)

Parameters

# split_route_id(id)

Parameters

# all(config, mode)

Run sync.init and sync.create in series, returning the result from sync.create.

Parameters

# all_types(config, mode)

Run sync.init and then generate all type files.

Parameters

# create(config)

Update SvelteKit's generated files

Parameters

# init(config, mode)

Initialize SvelteKit's generated files.

Parameters

# server(config)

Regenerate SERVER/internal.js in response to src/{app.html,error.html,service-worker.js} changing

Parameters

# update(config, manifest_data, file)

Update SvelteKit's generated files in response to a single file content update. Do not call this when the file in question was created/deleted.

Parameters

# dedent_map()

# previous_contents()

# write(file, code)

Parameters

# write_if_changed(file, code)

Parameters

# read_description(filename)

Parameters

# template(env, prefix)

Parameters

# write_ambient(config, mode)

Writes ambient declarations including types reference to @sveltejs/kit, and the existing environment variables in process.env to $env/static/private and $env/static/public

Parameters

# generate_node(node)

Creates a module that exports a CSRPageNode

Parameters

# write_client_manifest(kit, manifest_data, output, metadata)

Writes the client manifest to disk. The manifest is used to power the router. It contains the list of routes and corresponding Svelte components (i.e. pages and layouts).

Parameters

# write_root(manifest_data, output)

Parameters

# relative(file)

Parameters

# server_template(opts)

Parameters

# config_relative(file)

Parameters

# config_relative(file)

Parameters

# get_tsconfig(kit, include_base_url)

Generates the tsconfig that the user's tsconfig inherits from.

Parameters

# get_tsconfig_paths(config, include_base_url)

Generates tsconfig path aliases from kit's aliases. Related to vite alias creation.

Parameters

# lib()

# lib_()

# load_user_tsconfig(cwd)

Parameters

# maybe_file(cwd, file)

Parameters

# paths()

# project_relative(file)

Parameters

# remove_trailing_slashstar(file)

Parameters

# validate_user_config(kit, cwd, out, config)

Parameters

# write_tsconfig(kit)

Generates the tsconfig that the user's tsconfig inherits from.

Parameters

# create_routes_map(manifest_data)

Collect all leafs into a leaf -> route map

Parameters

# createProxy(file_path, is_server)

Parameters

# cwd()

# data()

# declarations()

# declarations()

# ensureProxies(node, proxies)

This function populates the proxies object, if necessary and not already done. Proxies are used to tweak the code of a file before it's typechecked. They are needed in two places - when generating the types for a page or layout. To not do the same work twice, we generate the proxies once and pass them around.

Parameters

# exports()

# exports()

# get_data_type(file_path, fallback, proxy, expand)

Parameters

# get_parent_type(node, type)

Get the parent type string by recursively looking up the parent layout and accumulate them to one type.

Parameters

# input_files()

# map()

# node()

# path_to_original(outdir, file_path)

Parameters

# process_node(node, outdir, is_page, proxies, all_pages_have_load)

Parameters

# replace_ext_with_js(file_path)

Parameters

# replace_jsdoc_type_tags(node, value)

Parameters

# route.layout()

# server_data()

# tweak_types(content, is_server)

Parameters

# update_types(config, routes, route, to_delete)

Update types for a specific route

Parameters

# write_types(config, manifest_data, file)

Creates types related to the given file. This should only be called if the file in question was edited, not if it was created/deleted/moved.

Parameters

# actions()

# actions()

# c()

# c(param)

Parameters

# load()

test

# load()

test

# load()

# load(event)

Parameters

# load()

# load(event)

Parameters

# load()

# load(event)

Parameters

# submit()

Ordinarily this would live in a +page.svelte, but to make it easy to run the tests, we put it here. The export is so that eslint doesn't throw a hissy fit about the unused variable

# data()

# data()

# load()

# load()

# load()

# data()

# load()

# data()

# load()

# actionData()

# data()

# load()

# data()

# load()

# load()

# load()

# load()

# load()

# load()

# a()

# load()

# err(msg)

Parameters

# get_mime_lookup(manifest_data)

Parameters

# log()

# logger(opts)

Parameters

# mime()

# runtime_base()

This allows us to import SvelteKit internals that aren't exposed via pkg.exports in a way that works whether @sveltejs/kit is installed inside the project's node_modules or in a workspace root

# runtime_directory()

Resolved path of the runtime directory TODO Windows issue: Vite or sth else somehow sets the driver letter inconsistently to lower or upper case depending on the run environment. In playwright debug mode run through VS Code this a root-to-lowercase conversion is needed in order for the tests to run. If we do this conversion in other cases it has the opposite effect though and fails.

# apply_handle(i, event, parent_options)

Parameters

# filterSerializedResponseHeaders()

# preload()

# sequence(handlers)

A helper function for sequencing multiple handle calls in a middleware-like manner. The behavior for the handle options is as follows: - transformPageChunk is applied in reverse order and merged - preload is applied in forward order, the first option "wins" and no preload options after it are called - filterSerializedResponseHeaders behaves the same as preload js /// file: src/hooks.server.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, { transformPageChunk: ({ html }) => { // transforms are applied in reverse order console.log('first transform'); return html; }, preload: () => { // this one wins as it's the first defined in the chain console.log('first preload'); } }); 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, { transformPageChunk: ({ html }) => { console.log('second transform'); return html; }, preload: () => { console.log('second preload'); }, filterSerializedResponseHeaders: () => { // this one wins as it's the first defined in the chain console.log('second filterSerializedResponseHeaders'); } }); console.log('second post-processing'); return result; } export const handle = sequence(first, second); The example above would print: first pre-processing first preload second pre-processing second filterSerializedResponseHeaders second transform first transform second post-processing first post-processing

Parameters

# transformPageChunk()

# error(status, body)

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. Make sure you're not catching the thrown error, which would prevent SvelteKit from handling it.

Parameters

# fail(status, data)

Create an ActionFailure object.

Parameters

# json(data, init)

Create a JSON Response object from the supplied data.

Parameters

# redirect(status, location)

Create a Redirect object. If thrown during request handling, SvelteKit will return a redirect response. Make sure you're not catching the thrown redirect, which would prevent SvelteKit from handling it.

Parameters

# resolvePath(id, params)

Populate a route ID with params to resolve a pathname.

Parameters

# text(body, init)

Create a Response object from the supplied body.

Parameters

# get_raw_body(req, body_size_limit)

Parameters

# globals()

# installPolyfills()

Make various web APIs available as globals: - crypto - fetch - Headers - Request - Response

# ...deps()

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 invalidated after a button click, making the load function rerun. js /// file: src/routes/+page.js let count = 0; export async function load({ depends }) { depends('increase:count'); return { count: count++ }; } html /// file: src/routes/+page.svelte <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>

# ...deps()

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 invalidated after a button click, making the load function rerun. js /// file: src/routes/+page.js let count = 0; export async function load({ depends }) { depends('increase:count'); return { count: count++ }; } html /// file: src/routes/+page.svelte <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>

# _()

private fields

# adapt(builder)

This function is called after SvelteKit has built your app.

Parameters

# App.Error()

The error object of the current page, if any. Filled from the handleError hooks.

# App.Error()

The content of the error.

# App.Locals()

Contains custom data that was added to the request within the handle hook.

# App.PageData()

The merged result of all data from all load functions on the current page. You can type a common denominator through App.PageData.

# App.Platform()

Additional data made available through the adapter.

# cancel()

Call this to prevent the navigation from starting.

# compress(directory)

Compress files in directory with gzip and brotli, where appropriate. Generates .gz and .br files alongside the originals.

Parameters

# config()

The fully resolved svelte.config.js.

# config()

A function that allows you to edit the generated tsconfig.json. You can mutate the config (recommended) or return a new one. This is useful for extending a shared tsconfig.json in a monorepo root, for example.

# cookies()

Get or set cookies related to the current request

# copy(from, to, opts.filter, opts.replace)

Copy a file or directory.

Parameters

# createEntries(fn)

Create separate functions that map to one or more routes of your app.

Parameters

# data()

Contains the data returned by the route's server load function (in +layout.server.js or +page.server.js), if any.

# data()

use formData instead of data

# data()

use formData instead of data

# delete(name, opts)

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.

Parameters

# e()

A root-relative path that must start, but not end with / (e.g. /base-path), unless it is the empty string. This specifies where your app is served from and allows the app to live on a non-root path. Note that you need to prepend all your root-relative links with the base value or they will point to the root of your domain, not your base (this is how the browser works). You can use base from $app/paths for that: <a href="{base}/your-page">Link</a>. If you find yourself writing this often, it may make sense to extract this into a reusable component.

# 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 and authorization 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 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.

# 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 and authorization 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 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.

# filepath()

Determine which files in your static directory will be available in $service-worker.files.

# form()

Filled only after a form submission. See form actions for more info.

# form()

use formElement instead of form

# form()

use formElement instead of form

# from()

Where navigation was triggered from

# generateFallback()

Generate a fallback page for a static webserver to use when no route is matched. Useful for single-page apps.

# generateManifest(opts)

Generate a server-side manifest to initialise the SvelteKit server with.

Parameters

# get(name, opts)

Gets a cookie that was previously set with cookies.set, or from the request headers.

Parameters

# getAll(opts)

Gets all cookies that were previously set with cookies.set, or from the request headers.

Parameters

# getAppPath()

Get the application path including any configured base path, e.g. /my-base-path/_app.

# getBuildDirectory(name)

Resolve a path to the name directory inside outDir, e.g. /path/to/.svelte-kit/my-adapter.

Parameters

# getClientAddress()

The client's IP address, set by the adapter.

# getClientDirectory()

Get the fully resolved path to the directory containing client-side assets, including the contents of your static directory.

# getServerDirectory()

Get the fully resolved path to the directory containing server-side code.

# h()

Whether to use hashes or nonces to restrict <script> and <style> elements. 'auto' will use hashes for prerendered pages, and nonces for dynamically rendered pages.

# http()

An absolute path that your app's files are served from. This is useful if your files are served from a storage bucket of some kind.

# id()

The ID of the current route - e.g. for src/routes/blog/[slug], it would be /blog/[slug]

# id()

The ID of the current route - e.g. for src/routes/blog/[slug], it would be /blog/[slug]

# id()

The ID of the current route - e.g. for src/routes/blog/[slug], it would be /blog/[slug]

# input()

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).

# input()

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.

# input()

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.

# input()

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)

# input(input)

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.

Parameters

# input(input)

Determines what should be added to the <head> tag to preload it. By default, js and css files will be preloaded.

Parameters

# isDataRequest()

true if the request comes from the client asking for +page/layout.server.js 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.

# key()

Any additional options required by tooling that integrates with Svelte.

# location()

The location to redirect to.

# log()

Print messages to the console. log.info and log.minor are silent unless Vite's logLevel is info.

# mkdirp()

Create dir and any required parent directories.

# name()

The name of the adapter, using for logging. Will typically correspond to the package name.

# name(name, value)

Determines which headers should be included in serialized responses when a load function loads a resource with fetch. By default, none will be included.

Parameters

# param()

The shape of a param matcher. See matching for more info.

# params()

The parameters of the current page - e.g. for a route like /blog/[slug], a { slug: string } object

# params()

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).

# params()

The parameters of the current page - e.g. for a route like /blog/[slug], a { slug: string } object

# params()

The parameters of the current route - e.g. for a route like /blog/[slug], a { slug: string } object

# parent()

await parent() returns data from parent +layout.js load functions. Implicitly, a missing +layout.js is treated as a ({ data }) => data function, meaning that it will return and forward data from parent +layout.server.js 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.

# parent()

await parent() returns data from parent +layout.server.js 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.

# prerendered()

Information about prerendered pages and assets, if any.

# request()

The original request object

# rimraf()

Remove dir and all its contents.

# route()

Info about the current route

# route()

Info about the target route

# route()

Info about the current route

# route()

Info about the current route

# routes()

An array of all routes (including prerendered)

# serialize(name, value, opts)

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.

Parameters

# set(name, value, opts)

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.

Parameters

# setHeaders()

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: js /// file: src/routes/blog/+page.js export async function load({ fetch, setHeaders }) { const url = `https://cms.example.com/articles.json`; const response = await fetch(url); setHeaders({ age: response.headers.get('age'), 'cache-control': response.headers.get('cache-control') }); return response.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.

# setHeaders()

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: js /// file: src/routes/blog/+page.js export async function load({ fetch, setHeaders }) { const url = `https://cms.example.com/articles.json`; const response = await fetch(url); setHeaders({ age: response.headers.get('age'), 'cache-control': response.headers.get('cache-control') }); return response.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.

# status()

Http status code of the current page

# status()

The HTTP status code, in the range 400-599.

# status()

The HTTP status code, in the range 300-308.

# to()

Where navigation is going to/has gone to

# type()

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 document - link: Navigation was triggered by a link click - goto: Navigation was triggered by a goto(...) call or a redirect - popstate: Navigation was triggered by back/forward navigation

# type()

The type of navigation: - enter: The app has hydrated - form: The user submitted a <form> - link: Navigation was triggered by a link click - goto: Navigation was triggered by a goto(...) call or a redirect - popstate: Navigation was triggered by back/forward navigation

# update(options)

Call this to get the default behavior of a form submission response.

Parameters

# url()

The URL of the current page

# url()

The URL that is navigated to

# url()

The URL of the current page

# url()

The requested URL.

# willUnload()

Whether or not the navigation will result in the page being unloaded (i.e. not a client-side navigation)

# willUnload()

Since afterNavigate is called after a navigation completes, it will never be called with a navigation that unloads the page.

# writeClient(dest)

Write client assets to dest.

Parameters

# writePrerendered(dest)

Write prerendered files to dest.

Parameters

# writeServer(dest)

Write server-side code to dest.

Parameters

# build_server_nodes(out, kit, manifest_data, server_manifest, client_manifest, css)

Parameters

# exports()

# fonts()

# imported()

# imports()

# styles()

# stylesheets()

# assets_base(config)

Parameters

# find_deps(manifest, entry, add_dynamic_css)

Adds transitive JS and CSS dependencies to the js and css inputs.

Parameters

# fonts()

# imports()

# is_http_method(str)

Parameters

# resolve_symlinks(manifest, file)

Parameters

# seen()

# stylesheets()

# traverse(current, add_js)

Parameters

# add(node)

Parameters

# add_by_url(url)

Parameters

# branches()

# debounce(to_run)

Parameters

# dev(vite, vite_config, svelte_config)

Parameters

Returns

Promise<Promise<() => void>>

# error_template(opts)

Parameters

# find_deps(vite, node, deps)

Parameters

# fix_stack_trace(stack)

Parameters

# has_correct_case(file, assets)

Determine if a file is being requested with the correct case, to ensure consistent behaviour between dev and prod and across operating systems. Note that we can't use realpath here, because we don't want to follow symlinks

Parameters

# loud_ssr_load_module(url)

Parameters

# manifest()

# manifest_data()

# manifest_error()

# matchers()

# remove_static_middlewares(server)

Parameters

# result()

# styles()

# timeout()

# watch(event, cb)

Parameters

# check(id)

Parameters

# follow(id, chain)

Parameters

# is_illegal(id, dirs)

Checks if given id imports a module that is not allowed to be imported into client-side code.

Parameters

# module_guard(context, paths)

Creates a guard that checks that no id imports a module that is not allowed to be imported into client-side code.

Parameters

# normalize_id(id, lib, cwd)

Removes cwd/lib path from the start of the id

Parameters

# seen()

# getModuleInfo(id)

Parameters

# remove_query_from_id(path)

Parameters

# buildStart()

Clears the output directories.

# closeBundle()

Runs the adapter.

# config()

Build the SvelteKit-provided Vite config to be merged with the user's vite.config.js file.

# config()

Build the SvelteKit-provided Vite config to be merged with the user's vite.config.js file.

# configResolved()

Stores the final config.

# configurePreviewServer()

Adds the SvelteKit middleware to do SSR in preview mode.

# configureServer()

Adds the SvelteKit middleware to do SSR in dev mode.

# create_service_worker_module(config)

Parameters

# enforced_config()

# env()

# finalise()

# find_overridden_config(config, resolved_config, enforced_config, path, out)

Parameters

# input()

# is_build()

# kit(options)

Returns the SvelteKit Vite plugin. Vite executes Rollup hooks as well as some of its own. Background reading is available at: - https://vitejs.dev/guide/api-plugin.html - https://rollupjs.org/guide/en/#plugin-development You can get an idea of the lifecycle by looking at the flow charts here: - https://rollupjs.org/guide/en/#build-hooks - https://rollupjs.org/guide/en/#output-generation-hooks

Parameters

Returns

import('vite').Plugin[]

# manifest_data()

# plugin_compile()

# plugin_guard()

Ensures that client-side code can't accidentally import server-side code, whether in *.server.js files, $lib/server, or $env/[static|dynamic]/private

# plugin_setup()

# plugin_virtual_modules()

# preprocess()

# server_manifest()

# set_assets(path)

Parameters

# sveltekit()

Returns the SvelteKit Vite plugins.

# value.type()

# vite_config()

# vite_config_env()

# vite_plugin_svelte_options()

# warn_overridden_config(config, resolved_config)

Parameters

# warned()

# warning_preprocessor()

# writeBundle()

Vite builds a single bundle. We need three bundles: client, server, and service worker. The user's package.json scripts will invoke the Vite CLI to execute the server build. We then use this hook to kick off builds for the client and service worker.

# internal.js()

# is_file(path)

Parameters

# mutable(dir)

Parameters

# preview(vite, vite_config, svelte_config)

Parameters

# scoped(scope, handler)

Parameters

# alias()

# escape_for_regexp(str)

Parameters

# get_config_aliases(config)

Transforms kit.alias to a valid vite.resolve.alias array. Related to tsconfig path alias creation.

Parameters

# get_env(env_config, mode)

Load environment variables from process.env and .env files

Parameters

# not_found(req, res, base)

Parameters

# browser()

true if the app is running in the browser.

# dev()

Whether the dev server is running. This is not guaranteed to correspond to NODE_ENV or MODE.

# applyAction(result)

This action updates the form property of the current page with the given data and updates $page.status. In case of an error, it redirects to the nearest error page.

Parameters

# deserialize(result)

Use this function to deserialize the response from a form submission. Usage: js import { deserialize } from '$app/forms'; async function handleSubmit(event) { const response = await fetch('/form?/action', { method: 'POST', body: new FormData(event.target) }); const result = deserialize(await response.text()); // ... }

Parameters

# enhance(form_element, submit)

This action enhances a <form> element that otherwise would work without JavaScript. The submit function is called upon submission with the given FormData and the action that should be triggered. If cancel is called, the form will not be submitted. You can use the abort controller to cancel the submission in case another one starts. If a function is returned, that function is called with the response from the server. If nothing is returned, the fallback will be used. If this function or its return value isn't set, it - falls back to updating the form prop with the returned data if the action is one same page as the form - updates $page.status - resets the <form> element and invalidates all data in case of successful submission with no redirect response - redirects in case of a redirect response - redirects to the nearest error page in case of an unexpected error If you provide a custom function with a callback and want to use the default behavior, invoke update in your callback.

Parameters

# fallback_callback(opts)

Parameters

# result()

# warn_on_access(old_name, new_name, call_location)

Parameters

# afterNavigate(callback)

A lifecycle function that runs the supplied callback when the current component mounts, and also whenever we navigate to a new URL. afterNavigate must be called during a component initialization. It remains active as long as the component is mounted.

Parameters

# beforeNavigate(callback)

A navigation interceptor that triggers before we navigate to a new URL, whether by clicking a link, calling goto(...), or using the browser back/forward controls. Calling cancel() will prevent the navigation from completing. If the navigation would have directly unloaded the current page, calling cancel will trigger the native browser unload confirmation dialog. In these cases, navigation.willUnload is true. When a navigation isn't client side, navigation.to.route.id will be null. beforeNavigate must be called during a component initialization. It remains active as long as the component is mounted.

Parameters

# disableScrollHandling()

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.

# goto(url, opts, opts.replaceState, opts.noScroll, opts.keepFocus, invalidateAll, opts.state)

Returns a Promise that resolves when SvelteKit navigates (or fails to navigate, in which case the promise rejects) to the specified url. For external URLs, use window.location = url instead of calling goto(url).

Parameters

# invalidate(url)

Causes any load functions belonging to the currently active page to re-run if they depend on the url in question, via fetch or depends. Returns a Promise that resolves when the page is subsequently updated. If the argument is given as a string or URL, it must resolve to the same URL that was passed to fetch or depends (including query parameters). To create a custom identifier, use a string beginning with [a-z]+: (e.g. custom:state) — this is a valid URL. The function argument can be used define a custom predicate. It receives the full URL and causes load to rerun if true is returned. This can be useful if you want to invalidate based on a pattern instead of a exact match. ts // Example: Match '/path' regardless of the query parameters import { invalidate } from '$app/navigation'; invalidate((url) => url.pathname === '/path');

Parameters

# invalidateAll()

Causes all load functions belonging to the currently active page to re-run. Returns a Promise that resolves when the page is subsequently updated.

# preloadCode(urls)

Programmatically imports the code for routes that haven't yet been fetched. Typically, you might call this to speed up subsequent navigation. You can specify routes by any matching pathname such as /about (to match src/routes/about/+page.svelte) or /blog/* (to match src/routes/blog/[slug]/+page.svelte). Unlike preloadData, this won't call load functions. Returns a Promise that resolves when the modules have been imported.

Parameters

# preloadData(href)

Programmatically preloads 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 data-sveltekit-preload-data. 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 preload is complete.

Parameters

# get_store(name)

Parameters

# getStores()

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.

# navigating()

# navigating()

A readable store. When navigating starts, its value is a Navigation object with from, to, type and (if type === 'popstate') delta properties. When navigating finishes, its value reverts to null. On the server, this store can only be subscribed to during component initialization. In the browser, it can be subscribed to at any time.

# page()

# page()

A readable store whose value contains page data. On the server, this store can only be subscribed to during component initialization. In the browser, it can be subscribed to at any time.

# stores.updated()

# updated()

A readable store whose initial value is false. If version.pollInterval 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. On the server, this store can only be subscribed to during component initialization. In the browser, it can be subscribed to at any time.

# after_navigate()

# before_navigate()

# before_navigate(opts)

Parameters

# branch()

# branch()

# capture_snapshot(index)

Parameters

# components()

An array of the +layout.svelte and +page.svelte component instances that currently live on the page — used for capturing and restoring snapshots. It's updated/manipulated through bind:this in Root.svelte.

# create_client(app, target)

Parameters

# create_data_node(node, previous)

Parameters

# current()

# data()

# depends(deps)

Parameters

# deserialize_uses(uses)

Parameters

Returns

import('types').Uses

# get_navigation_intent(url, invalidating)

Parameters

# get_navigation_result_from_branch(opts)

Parameters

# get_url_path(url)

Parameters

# goto(url, opts, redirect_chain, nav_token)

Parameters

# has_changed(parent_changed, route_changed, url_changed, uses, params)

Parameters

# hydrated()

this being true means we SSR'd

# intent()

# invalidated()

# load_cache()

# load_data(url, invalid)

Parameters

# load_input()

# load_node(options)

Call the load function of the given node, if it exists. If server_data is passed, this is treated as the initial run and the page endpoint is not requested.

Parameters

# load_root_error_page(opts)

Parameters

# load_route(intent)

Parameters

# native_navigation(url)

Loads href the old-fashioned way, with a full page reload. Returns a Promise that never resolves (to prevent any subsequent work, e.g. history manipulation, from happening)

Parameters

# navigate(opts)

Parameters

# navigation()

# navigation()

# navigation()

# page()

# params()

# pending_invalidate()

# preload(element, priority)

Parameters