kit-monorepo (main)

# 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()

# developers.cloudflare.com()

# validate_config(builder, config_file)

Parameters

# generate_headers(app_dir)

Parameters

# generate_redirects(redirects)

Parameters

# get_routes_json(builder, assets, routes)

Parameters

# worker()

# edge_manifest()

# function()

# generate_edge_functions(params, params.builder)

Parameters

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

Parameters

# matches(a, b)

Parameters

# name()

# 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

# parse_body_size_limit(bytes)

Parameters

# return()

# sequence(handlers)

Parameters

# serve(path, client)

Parameters

# serve_prerendered()

# ssr()

# graceful_shutdown(reason)

Parameters

# idle_timeout_id()

# shutdown_timeout_id()

# is()

# overrides()

# platforms()

# prerendered_redirects()

# static_vercel_config(builder)

Parameters

# load()

# GET()

# GET()

# config()

# config()

# config()

# config()

# config()

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

# 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_serverless_function()

# groups()

# hash_config(config)

Parameters

# images()

# is_prerendered(route)

Parameters

# isr_config()

# overrides()

# prerendered_redirects()

# static_vercel_config(builder, config, dir)

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

# run_pattern_to_src_test(route_id, expected)

Parameters

# get_pathname(route)

Parameters

# pattern_to_src(pattern)

Adjusts the stringified route regex for Vercel's routing system

Parameters

# transform(html)

Parameters

# enhancedImages()

# fallback()

# get_widths(width, sizes)

Parameters

# image_plugin(imagetools_plugin)

Creates the Svelte image plugin which provides the preprocessor.

Parameters

# imagetools_opts()

# opts()

# attributes()

# consts()

Vite name to declaration name e.g. VITE_ASSET_0 => DECLARED_ASSET_0

# dynamic_img_to_picture(content, node, src_var_name)

For images like <img src={manually_imported} />

Parameters

# image(opts)

Parameters

# images()

URL to image details

# img_to_picture(consts, content, node, image)

Parameters

# imports()

Import path to import name e.g. ./foo.png => IMPORTED_ASSET_0

# is_quote(content, index)

Parameters

# node()

# parseObject(str)

Parameters

# process(resolved_id, opts)

Parameters

# serialize_img_attributes(content, attributes, details)

Parameters

# stringToNumber(param)

Parameters

# to_value(consts, src)

Parameters

# update_element(node, src_attribute)

Parameters

# user_height()

# user_width()

# 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()

# 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, prefixes)

Parameters

# create_static_module(id, env)

Parameters

# create_static_types(id, env)

Parameters

# declarations()

# add_assets(id)

Parameters

# find_server_assets(build_data, routes)

Finds all the assets that are imported by server files associated with routes

Parameters

# server_assets()

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

# files()

# 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()

# manifest_expr()

# 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

# analyse_endpoint(route, mod)

Parameters

# analyse_page(layouts, leaf)

Parameters

# config()

# internal()

# manifest()

# metadata()

# methods()

# visit(id)

Parameters

# 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()

# dependencies()

# 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_hooks(config, cwd)

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

# matchers()

# nodes()

# normalize_route_id(id)

Parameters

# prevent_conflicts(routes)

Parameters

# route()

# routes()

# walk(depth, id, segment, parent)

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

# VERSION()

# write(file, code)

Parameters

# write_if_changed(file, code)

Parameters

# read_description(filename)

Parameters

# template(env, prefixes)

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_non_ambient(config)

Writes non-ambient declarations to the output directory

Parameters

# write_root(manifest_data, output)

Parameters

# relative(file)

Parameters

# server_template(opts)

Parameters

# write_server(config, output)

Write server configuration to disk

Parameters

# config_relative(file)

Parameters

# config_relative(file)

Parameters

# get_tsconfig(kit)

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

Parameters

# get_tsconfig_paths(config)

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

Parameters

# load_user_tsconfig(cwd)

Parameters

# maybe_file(cwd, file)

Parameters

# paths()

# project_relative(file)

Parameters

# remove_trailing_slashstar(file)

Parameters

# validate_user_config(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()

# generate_params_type(params, outdir, config)

Parameters

# 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()

# layout_params()

# map()

# node()

# path_to_matcher(matcher)

Parameters

# 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()

# a()

# load()

# match(param)

Parameters

# match(param)

Parameters

# a()

# a()

# b()

# load()

# a()

# load()

# a()

# b()

# load()

# a()

# load()

# data()

# load()

# actionData()

# data()

# load()

# data()

# load()

# load()

# load()

# load()

# load()

# load()

# a()

# load()

# err(msg)

Parameters

# files()

# get_mime_lookup(manifest_data)

Parameters

# list_files(dir, filter)

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.

# walk(current)

Parameters

# 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'); return true; } }); 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'); return true; }, filterSerializedResponseHeaders: () => { // this one wins as it's the first defined in the chain console.log('second filterSerializedResponseHeaders'); return true; } }); 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)

Throws an error with a HTTP status code and an optional message. When called during request handling, this 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

Returns

never

# fail(status, data)

Create an ActionFailure object.

Parameters

# isActionFailure(e)

Checks whether this is an action failure thrown by {@link fail}.

Parameters

Returns

e is import('./public.js').ActionFailure

# isHttpError(e, status)

Checks whether this is an error thrown by {@link error}.

Parameters

Returns

e is (HttpError & { status: T extends undefined never : T })

# isRedirect(e)

Checks whether this is a redirect thrown by {@link redirect}.

Parameters

Returns

e is Redirect

# json(data, init)

Create a JSON Response object from the supplied data.

Parameters

# redirect(status, location)

Redirect a request. When called 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

Returns

never

# 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 - File

# ...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'; let { data } = $props(); 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'; let { data } = $props(); 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 server 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.PageState()

The page state, which can be manipulated using the pushState and replaceState functions from $app/navigation.

# App.Platform()

A function that is called with the current route config and prerender option and returns an App.Platform object

# App.Platform()

Additional data made available through the adapter.

# cancel()

Call this to prevent the navigation from starting.

# complete()

A promise that resolves once the navigation is complete, and rejects if the navigation fails or is aborted. In the case of a willUnload navigation, the promise will never resolve

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

# delete(name, opts)

Deletes a cookie by setting its value to an empty string and setting the expiry date in the past. You must specify a path for the cookie. In most cases you should explicitly set path: '/' to make the cookie available throughout your app. You can use relative paths, or set path: '' to make the cookie only available on the current path and its children

Parameters

# details(config)

Test support for read from $app/server

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.

# env()

A map of environment variables

# event()

The reroute hook allows you to modify the URL before it is used to determine which route to render.

# 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 by hooking into the text and json methods of the Response object. 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. You can learn more about making credentialed requests with cookies here

# 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 by hooking into the text and json methods of the Response object. 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. You can learn more about making credentialed requests with cookies here

# file()

A function that turns an asset filename into a ReadableStream. Required for the read export from $app/server to work

# filepath()

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

# fn()

Use this function to opt out of dependency tracking for everything that is synchronously called within the callback. Example: js /// file: src/routes/+page.server.js export async function load({ untrack, url }) { // Untrack url.pathname so that path changes don't trigger a rerun if (untrack(() => url.pathname === '/')) { return { message: 'Welcome!' }; } }

# fn()

Use this function to opt out of dependency tracking for everything that is synchronously called within the callback. Example: js /// file: src/routes/+page.js export async function load({ untrack, url }) { // Untrack url.pathname so that path changes don't trigger a rerun if (untrack(() => url.pathname === '/')) { return { message: 'Welcome!' }; } }

# form()

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

# from()

Where navigation was triggered from

# generateEnvModule()

Generate a module exposing build-time environment variables as $env/dynamic/public.

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

# isSubRequest()

true for +server.js calls coming from SvelteKit without the overhead of actually making an HTTP request. This happens when you make same-origin fetch requests on the server.

# 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. You must specify a path for the cookie. In most cases you should explicitly set path: '/' to make the cookie available throughout your app. You can use relative paths, or set path: '' to make the cookie only available on the current path and its children

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. You must specify a path for the cookie. In most cases you should explicitly set path: '/' to make the cookie available throughout your app. You can use relative paths, or set path: '' to make the cookie only available on the current path and its children

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.

# sets()

Find all the assets imported by server files belonging to routes

# sets()

A [file]: size map of all assets imported by server code

# 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 app is being left either because the tab is being closed or a navigation to a different document is occurring - 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: - 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

# 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, invalidateAll)

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 onNavigate callbacks are called immediately before a client-side navigation, they will never be called with a navigation that unloads the page.

# willUnload()

Since afterNavigate callbacks are called after a navigation completes, they 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()

# build_service_worker(out, kit, vite_config, manifest_data, service_worker_entry_file, prerendered, client_manifest)

Parameters

# sw_virtual_modules()

# assets_base(config)

Parameters

# find_deps(manifest, entry, add_dynamic_css)

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

Parameters

# imported_assets()

# 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

# deps()

# dev(vite, vite_config, svelte_config)

Parameters

Returns

Promise<Promise<() => void>>

# error_template(opts)

Parameters

# find_deps(vite, node, deps)

Parameters

# fix_stack_trace(error)

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

# import_map()

# initial_config()

# 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

Promise<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, $app/server, $lib/server, or $env/[static|dynamic]/private

# plugin_setup()

# 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

# redirect()

# 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

# browser()

true if the app is running in the browser.

# building()

SvelteKit analyses your app during the build step by running it. During this process, building is true. This also applies during prerendering.

# dev()

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

# version()

The value of config.kit.version.name.

# 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 on the 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()

# resolveRoute()

# assets()

An absolute path that matches config.kit.paths.assets. > [!NOTE] 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.

# base()

A string that matches config.kit.paths.base. Example usage: <a href="{base}/your-page">Link</a>

# resolveRoute()

Populate a route ID with params to resolve a pathname.

# read(asset)

Read the contents of an imported asset from the filesystem

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.

# _before_navigate(opts)

Parameters

# _goto(url, options, redirect_count, nav_token)

Parameters

# _hydrate(target, opts)

Parameters

# _preload_code(pathname)

Parameters

# _preload_data(intent)

Parameters

# add_navigation_callback(callbacks, callback)

Parameters

# after_navigate_callbacks()

# 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

# app()

# 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

# before_navigate_callbacks()

# 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 navigation.type === 'leave' — meaning the user is navigating away from the app (or closing the tab) — calling cancel will trigger the native browser unload confirmation dialog. In this case, the navigation may or may not be cancelled depending on the user's response. When a navigation isn't to a SvelteKit-owned route (and therefore controlled by SvelteKit's client-side router), navigation.to.route.id will be null. If the navigation will (if not cancelled) cause the document to unload — in other words 'leave' navigations and 'link' navigations where navigation.to.route === null — navigation.willUnload is true. beforeNavigate must be called during a component initialization. It remains active as long as the component is mounted.

Parameters

# branch()

# branch()

# capture_snapshot(index)

Parameters

# clear_onward_history(current_history_index, current_navigation_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.

# container()

# create_data_node(node, previous)

Parameters