Skip to main content

Référence

Types

Éditer cette page sur Github

Public types

Les types suivants peuvent être importés depuis @sveltejs/kit :

Action

Type d'une action de formulaire qui fait partie de l'objet export const actions = {..} dans +page.server.js. Voir la section actions de formulaire pour plus d'informations.

ts
type Action<
Params extends Partial<Record<string, string>> = Partial<
Record<string, string>
>,
OutputData extends Record<string, any> | void = Record<
string,
any
> | void,
RouteId extends string | null = string | null
> = (
event: RequestEvent<Params, RouteId>
) => MaybePromise<OutputData>;

ActionFailure

ts
interface ActionFailure<
T extends Record<string, unknown> | undefined = undefined
> {}
ts
status: number;
ts
data: T;
ts
[uniqueSymbol]: true;

ActionResult

Lorsque vous exécutez une action de formulaire via fetch, la réponse aura une de ces formes.

<form method="post" use:enhance={() => {
  return ({ result }) => {
		// result is of type ActionResult
  };
}}
ts
type ActionResult<
Success extends
| Record<string, unknown>
| undefined = Record<string, any>,
Failure extends
| Record<string, unknown>
| undefined = Record<string, any>
> =
| { type: 'success'; status: number; data?: Success }
| { type: 'failure'; status: number; data?: Failure }
| { type: 'redirect'; status: number; location: string }
| { type: 'error'; status?: number; error: any };

Actions

Type de l'objet export const actions = {..} dans +page.server.js.. Voir la section actions de formulaire pour plus d'informations.

ts
type Actions<
Params extends Partial<Record<string, string>> = Partial<
Record<string, string>
>,
OutputData extends Record<string, any> | void = Record<
string,
any
> | void,
RouteId extends string | null = string | null
> = Record<string, Action<Params, OutputData, RouteId>>;

Adapter

Les adaptateurs sont responsables de transformer votre build de production en quelque chose qui pourra être déployé sur une plateforme de votre choix.

ts
interface Adapter {}
ts
name: string;

Le nom de l'adaptateur, utile pour logguer. Correspond normalement au nom du paquet.

ts
adapt(builder: Builder): MaybePromise<void>;
  • builder Un objet fourni par SvelteKit contenant des méthodes pour adpater votre application

Cette fonction est exécutée après que SvelteKit a compilé votre application.

ts
supports?: {}

Checks called during dev and build to determine whether specific features will work in production with this adapter

ts
read?: (details: { config: any; route: { id: string } }) => boolean;
  • config The merged route config

Test support for read from $app/server

ts
emulate?(): MaybePromise<Emulator>;

Creates an Emulator, which allows the adapter to influence the environment during dev, build and prerendering

AfterNavigate

L'argument passé aux callbacks afterNavigate.

ts
interface AfterNavigate extends Omit<Navigation, 'type'> {}
ts
type: Exclude<NavigationType, 'leave'>;

Le type de navigation :

  • enter: L'application a été hydratée
  • form: L'utilisateur ou utilisatrice a soumis un <form>
  • link: La navigation a été déclenchée par un clic sur un lien
  • goto: La navigation a été déclenchée par un appel à goto(...) ou une redirection
  • popstate: La navigation a été déclenchée par les boutons précédent/suivant du navigateur
ts
willUnload: false;

Puisque les callbacks afterNavigate sont exécutés après la fin d'une navigation, ils ne seront jamais appelés lorsqu'une navigation décharge la page.

AwaitedActions

ts
type AwaitedActions<
T extends Record<string, (...args: any) => any>
> = OptionalUnion<
{
[Key in keyof T]: UnpackValidationError<
Awaited<ReturnType<T[Key]>>
>;
}[keyof T]
>;

BeforeNavigate

L'argument passé aux callbacks beforeNavigate.

ts
interface BeforeNavigate extends Navigation {}
ts
cancel(): void;

Appelez cette méthode pour empêcher la navigation de démarrer.

Builder

Cet objet est passé à la fonction adapt des adaptateurs. Il contient différentes méthodes et propriétés qui sont utiles pour adapter votre application.

ts
interface Builder {}
ts
log: Logger;

Affiche des messages dans la console. log.info et log.minor sont silencieux à moins que l'option logLevel de Vite soit info.

ts
rimraf(dir: string): void;

Supprime dir et tout son contenu.

ts
mkdirp(dir: string): void;

Crée un dossier dir et tout dossier parent nécessaire.

ts
config: ValidatedConfig;

Le contenu du fichier svelte.config.js.

ts
prerendered: Prerendered;

Des informations sur les pages prérendues et ses fichiers statiques, s'il y en a.

ts
routes: RouteDefinition[];

Un tableau de toutes les routes (en incluant les routes prérendues).

ts
createEntries(fn: (route: RouteDefinition) => AdapterEntry): Promise<void>;
  • fn Une fonction qui regroupe un ensemble de routes en un point d'entrée
  • déprécié Utilisez plutôt builder.routes

Crée différentes fonctions qui correspondent à une ou plusieurs routes de votre application.

ts
findServerAssets(routes: RouteDefinition[]): string[];

Trouver l'ensemble des fichiers statiques importés par les scripts serveurs appartenant à routes.

ts
generateFallback(dest: string): Promise<void>;

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

ts
generateEnvModule(): void;

Génère les variables d'environnement à la compilation disponible dans $env/dynamic/public.

ts
generateManifest(opts: { relativePath: string; routes?: RouteDefinition[] }): string;
  • opts un chemin relatif vers le dossier de base de l'application, et en option le format (esm ou cjs) dans lequel le manifeste doit être généré

Génère un manifeste côté serveur avec lequel initialiser le serveur SvelteKit.

ts
getBuildDirectory(name: string): string;
  • name chemin vers le fichier, relatif au dossier compilé

Résout le chemin vers le fichier name dans outDir, par ex. /path/to/.svelte-kit/my-adapter.

ts
getClientDirectory(): string;

Récupère le chemin résolu complet vers le dossier contenant les fichiers statiques client, incluant le contenu de votre dossier static.

ts
getServerDirectory(): string;

Récupère le chemin résolu complet vers le dossier contenant le code serveur.

ts
getAppPath(): string;

Récupère le chemin de l'application en incluant un éventuel chemin configuré par base, par ex. my-base-path/_app.

ts
writeClient(dest: string): string[];
  • dest le dossier de destination
  • valeur de retour un tableau des fichiers écrits dans dest

Écrit les fichiers statiques client dans dest.

ts
writePrerendered(dest: string): string[];
  • dest le dossier de destination
  • valeur de retour un tableau des fichiers écrits dans dest

Écrit les fichiers prérendus dans dest.

ts
writeServer(dest: string): string[];
  • dest le dossier de destination
  • valeur de retour un tableau des fichiers écrits dans dest

Écrit les fichiers prérendus dans dest.

ts
copy(
from: string,
to: string,
opts?: {
filter?(basename: string): boolean;
replace?: Record<string, string>;
}
): string[];
  • from le fichier ou dossier source
  • to le fichier ou dossier de destination
  • opts.filter une fonction qui détermine si un fichier ou un dossier doit être copié
  • opts.replace un dictionnaire de chaînes de caractères à remplacer
  • valeur de retour un tableau des fichiers qui ont été copiés

Copie un fichier ou un dossier.

ts
compress(directory: string): Promise<void>;
  • directory Le dossier contenant les fichiers à compresser

Compresse les fichiers dans directory avec gzip et brotli, lorsque pertinent. Génère des fichiers .gz et .br au même endroit que les originaux.

Config

ts
interface Config {}

See the configuration reference for details.

Cookies

ts
interface Cookies {}
ts
get(name: string, opts?: import('cookie').CookieParseOptions): string | undefined;
  • name le nom du cookie
  • opts les options, passées directement à cookie.parse. Voir la documentation sur cette page (en anglais).

Récupère un cookie qui a été précédemment défini avec cookies.set, ou depuis les headers de requête.

ts
getAll(opts?: import('cookie').CookieParseOptions): Array<{ name: string; value: string }>;
  • opts les options, passées directement à cookie.parse. Voir la documentation sur cette page (en anglais).

Récupère tous les cookies qui ont été précédemment définis avec cookies.set, ou depuis les headers de requête.

ts
set(
name: string,
value: string,
opts: import('cookie').CookieSerializeOptions & { path: string }
): void;
  • name le nom du cookie
  • value la valeur du cookie
  • opts les options, passées directement à cookie.serialize. Voir la documentation sur cette page (en anglais).

Définit un cookie. Ceci va ajouter un header set-cookie à la réponse, mais aussi rendre le cookie disponible via cookies.get ou cookies.getAll pendant la requête courante.

Les options httpOnly et secure valent par défaut true (sauf sur http://localhost, où secure vaut false), et doivent être explicitement désactivées si vous voulez que les cookies soient lisibles par du code JavaScript côté client et/ou transmis via HTTP. L'option sameSite vaut par défaut lax.

Vous devez définir un path pour les cookies. Dans la plupart des cas, vous devriez explicitement définir path: '/' pour rendre le cookie disponible dans toute votre application. Vous pouvez utiliser des chemins relatifs, ou définir path: '' pour rendre le cookie disponible à la page courante et ses pages enfants

ts
delete(name: string, opts: import('cookie').CookieSerializeOptions & { path: string }): void;
  • name le nom du cookie
  • opts les options, passées directement à cookie.serialize. Voir la documentation ici (en anglais).

Supprime un cookie en définissant sa valeur comme une chaîne de caractères vide et sa date d'expiration à une valeur dans le passé.

Vous devez définir un path pour les cookies. Dans la plupart des cas, vous devriez explicitement définir path: '/' pour rendre le cookie disponible dans toute votre application. Vous pouvez utiliser des chemins relatifs, ou définir path: '' pour rendre le cookie disponible à la page courante et ses pages enfants

ts
serialize(
name: string,
value: string,
opts: import('cookie').CookieSerializeOptions & { path: string }
): string;
  • name le nom du cookie
  • value la valeur du cookie
  • opts les options, passées directement à cookie.serialize. Voir la documentation sur cette page (en anglais).

Sérialise une paire nom-valeur de cookie en une chaîne de caractères de header Set-Cookie, mais ne l'applique pas à la réponse.

Les options httpOnly et secure valent par défaut true (sauf sur http://localhost, où secure vaut false), et doivent être explicitement désactivées si vous voulez que les cookies soient lisibles par du code JavaScript côté client et/ou transmis via HTTP. L'option sameSite vaut par défaut lax.

Vous devez définir un path pour les cookies. Dans la plupart des cas, vous devriez explicitement définir path: '/' pour rendre le cookie disponible dans toute votre application. Vous pouvez utiliser des chemins relatifs, ou définir path: '' pour rendre le cookie disponible à la page courante et ses pages enfants

Emulator

A collection of functions that influence the environment during dev, build and prerendering

ts
interface Emulator {}
ts
platform?(details: { config: any; prerender: PrerenderOption }): MaybePromise<App.Platform>;

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

Handle

Le hook handle est exécuté à chaque fois que le serveur SvelteKit reçoit une requête et détermine la réponse. Il reçoit un objet event représentant la requête et un fonction appelée resolve, qui rend la route et génère une Response. Ceci vous permet de modifier les headers et body de réponse, ou de complètement contourner SvelteKit (par exemple pour implémenter certaines routes programmatiquement).

ts
type Handle = (input: {
event: RequestEvent;
resolve(
event: RequestEvent,
opts?: ResolveOptions
): MaybePromise<Response>;
}) => MaybePromise<Response>;

HandleClientError

Le hook handleError est exécuté côté client lorsqu'une erreur inattendue se produit pendant la navigation.

Si une erreur inattendue est levée pendant le chargement ou après le rendu, cette fonction est appelée avec l'erreur et un objet RequestEvent. Assurez-vous que cette fonction ne lève jamais d'erreur.

ts
type HandleClientError = (input: {
error: unknown;
event: NavigationEvent;
status: number;
message: string;
}) => MaybePromise<void | App.Error>;

HandleFetch

Le hook handleFetch vous permet de modifier (ou remplacer) une requête fetch qui se produit dans une fonction load exécutée sur le serveur (ou durant le prérendu).

ts
type HandleFetch = (input: {
event: RequestEvent;
request: Request;
fetch: typeof fetch;
}) => MaybePromise<Response>;

HandleServerError

Le hook handleError est exécuté sur le serveur lorsqu'une erreur inattendue se produit pendant que SvelteKit répond à une requête.

Si une erreur inattendue est levée pendant le chargement ou le rendu, cette fonction est appelée avec l'erreur et un objet RequestEvent. Assurez-vous que cette fonction ne lève jamais d'erreur.

ts
type HandleServerError = (input: {
error: unknown;
event: RequestEvent;
status: number;
message: string;
}) => MaybePromise<void | App.Error>;

HttpError

L'objet renvoyé par la fonction error

ts
interface HttpError {}
ts
status: number;

Le code représentant le statut HTTP, entre 400 et 599.

ts
body: App.Error;

Le contenu de l'erreur.

KitConfig

ts
interface KitConfig {}

See the configuration reference for details.

LessThan

ts
type LessThan<
TNumber extends number,
TArray extends any[] = []
> = TNumber extends TArray['length']
? TArray[number]
: LessThan<TNumber, [...TArray, TArray['length']]>;

Load

La forme générique de PageLoad et LayoutLoad. Vous devriez importer ces derniers depuis ./$types (voir la section Types générés) plutôt que d'utiliser Load directement.

ts
type Load<
Params extends Partial<Record<string, string>> = Partial<
Record<string, string>
>,
InputData extends Record<string, unknown> | null = Record<
string,
any
> | null,
ParentData extends Record<string, unknown> = Record<
string,
any
>,
OutputData extends Record<
string,
unknown
> | void = Record<string, any> | void,
RouteId extends string | null = string | null
> = (
event: LoadEvent<Params, InputData, ParentData, RouteId>
) => MaybePromise<OutputData>;

LoadEvent

La forme générique de PageLoadEvent et LayoutLoadEvent. Vous devriez importer ces derniers depuis ./$types (voir la section Types générés) plutôt que d'utiliser LoadEvent directement.

ts
interface LoadEvent<
Params extends Partial<Record<string, string>> = Partial<
Record<string, string>
>,
Data extends Record<string, unknown> | null = Record<
string,
any
> | null,
ParentData extends Record<string, unknown> = Record<
string,
any
>,
RouteId extends string | null = string | null
> extends NavigationEvent<Params, RouteId> {}
ts
fetch: typeof fetch;

La méthode fetch est équivalente à l'API web native fetch, avec quelques fonctionnalités additionnelles :

  • Vous pouvez l'utiliser pour faire des requêtes authentifiées sur le serveur, puisqu'elle hérite des headers cookie et authorization de la requête de page.
  • Elle peut faire des requêtes relatives sur votre serveur (d'habitude, fetch nécessite une URL avec une origine lorsqu'utilisée dans un contexte serveur).
  • Les requêtes internes (par ex. vers des routes +server.js) vont directement vers la fonction concernée si fetch est exécutée sur le serveur, sans la surcharge d'une requête HTTP.
  • Pendant le rendu côté serveur, la réponse est capturée et inlinée dans le HTML rendu en utilisant les méthodes text et json de l'objet Response. Notez que les headers ne seront pas sérialisés, à moins d'être inclus explicitement via filterSerializedResponseHeaders
  • Pendant l'hydratation, la réponse est lue depuis le HTML, en garantissant la cohérence et évitant une requête réseau supplémentaire.

Vous pouvez en apprendre plus sur les requêtes authentifiées avec cookies ici.

ts
data: Data;

Contient les données renvoyées par la fonction load serveur de votre route (dans +layout.server.js ou +page.server.js), si elle existe.

ts
setHeaders(headers: Record<string, string>): void;

Si vous avez besoin de définir des headers de réponse, vous pouvez le faire en utilisant cette méthode. Cela est utile si vous souhaitez changer la page à mettre en cache, par exemple :

src/routes/blog/+page.js
ts
export async function load({ fetch, setHeaders }) {
Binding element 'fetch' implicitly has an 'any' type.
Binding element 'setHeaders' implicitly has an 'any' type.
7031
7031
Binding element 'fetch' implicitly has an 'any' type.
Binding element 'setHeaders' implicitly has an 'any' type.
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();
}
src/routes/blog/+page.ts
ts
export async function load({ fetch, setHeaders }) {
Binding element 'fetch' implicitly has an 'any' type.
Binding element 'setHeaders' implicitly has an 'any' type.
7031
7031
Binding element 'fetch' implicitly has an 'any' type.
Binding element 'setHeaders' implicitly has an 'any' type.
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();
}

Définir le même header plusieurs fois (même dans des fonctions load différentes) est une erreur – vous pouvez définir un header donné seulement une seule fois. Vous ne pouvez pas ajouter un header set-cookie en même temps que vous utilisez setHeaders – utilisez plutôt l'API cookies dans une fonction load de serveur.

setHeaders n'a pas d'effet lorsque la fonction load est exécutée dans le navigateur.

ts
parent(): Promise<ParentData>;

await parent() renvoie les données des fonctions load des fichiers +layout.js parents. Implicitement, un fichier +layout.js manquant est traité comme une fonction ({ data }) => data, ce qui implique qu'elle va relayer les données des fichiers +layout.server.js parents.

Faites attention à ne pas introduire de "cascade" de chargement accidentelle lorsque vous utilisez await parent(). Si par exemple vous voulez uniquement fusionner les données du parent dans un objet à renvoyer, appelez cette fonction après avoir téléchargé vos autres données.

ts
depends(...deps: Array<`${string}:${string}`>): void;

Cette fonction déclare que la fonction load a comme dépendances une ou plusieurs URLs ou identifiants personnalisés, qui peuvent donc être utilisés avec invalidate() pour déclencher la réexécution de la méthode load.

La plupart du temps vous n'avez pas besoin d'utiliser ceci, puisque fetch appelle depends pour vous – c'est uniquement nécessaire si vous utilisez un client d'API personnalisé qui contourne fetch.

Les URLs peuvent être absolues ou relatives à la page qui est en train d'être chargée, et doivent être encodées.

Les identifiants personnaliés doivent être préfixés avec une ou plusieurs lettres en minuscules suivies d'un : pour satisfaire la spécification URI.

L'exemple suivant vous montre comment utiliser depends pour déclarer une dépendance à un identifiant personnalisé, qui sera invalidé avec invalidate après un clic sur un bouton, déclenchant la réexécution de la fonction load.

src/routes/+page.js
ts
let count = 0;
export async function load({ depends }) {
Binding element 'depends' implicitly has an 'any' type.7031Binding element 'depends' implicitly has an 'any' type.
depends('increase:count');
return { count: count++ };
}
src/routes/+page.ts
ts
let count = 0;
export async function load({ depends }) {
Binding element 'depends' implicitly has an 'any' type.7031Binding element 'depends' implicitly has an 'any' type.
depends('increase:count');
return { count: count++ };
}
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}>Augmenter le compteur</button>
ts
untrack<T>(fn: () => T): T;

Use this function to opt out of dependency tracking for everything that is synchronously called within the callback. Example:

src/routes/+page.server.js
ts
export async function load({ untrack, url }) {
Binding element 'untrack' implicitly has an 'any' type.
Binding element 'url' implicitly has an 'any' type.
7031
7031
Binding element 'untrack' implicitly has an 'any' type.
Binding element 'url' implicitly has an 'any' type.
// Untrack url.pathname so that path changes don't trigger a rerun
if (untrack(() => url.pathname === '/')) {
return { message: 'Welcome!' };
}
}
src/routes/+page.server.ts
ts
export async function load({ untrack, url }) {
Binding element 'untrack' implicitly has an 'any' type.
Binding element 'url' implicitly has an 'any' type.
7031
7031
Binding element 'untrack' implicitly has an 'any' type.
Binding element 'url' implicitly has an 'any' type.
// Untrack url.pathname so that path changes don't trigger a rerun
if (untrack(() => url.pathname === '/')) {
return { message: 'Welcome!' };
}
}

LoadProperties

ts
type LoadProperties<
input extends Record<string, any> | void
> = input extends void
? undefined // needs to be undefined, because void will break intellisense
: input extends Record<string, any>
? input
: unknown;

Navigation

ts
interface Navigation {}
ts
from: NavigationTarget | null;

L'endroit d'où la navigation a été déclenchée

ts
to: NavigationTarget | null;

L'endroit vers lequel la navigation est dirigée

ts
type: Exclude<NavigationType, 'enter'>;

Le type de navigation :

  • form: Un élément <form> a été soumis
  • leave: L'utilisateur ou utilisatrice quitte l'application en fermant l'onglet ou en naviguant vers un document différent
  • link: La navigation a été déclenchée par un clic sur un lien
  • goto: La navigation a été déclenchée par un appel à goto(...) ou une redirection
  • popstate: La navigation a été déclenchée par un navigation avec les boutons retour/suivant du navigateur
ts
willUnload: boolean;

Si oui ou non la navigation va déclencher le déchargement de la page (c'est-à-dire pas une navigation client)

ts
delta?: number;

Dans les cas d'une navigation via les boutons retour/suivant du navigateur, le nombre d'étapes vers l'avant ou l'arrière de l'historique

ts
complete: Promise<void>;

Un promesse qui se résout une fois la navigation terminée, et qui est rejetée si la navigation échoue ou est annulée. Dans le cas d'une navigation de type willUnload, la promise ne sera jamais résolue

NavigationEvent

ts
interface NavigationEvent<
Params extends Partial<Record<string, string>> = Partial<
Record<string, string>
>,
RouteId extends string | null = string | null
> {}
ts
params: Params;

Les paramètres de la page courante – par ex. un objet { slug: string } pour la route /blog/[slug]

ts
route: {}

Des informations sur la route courante

ts
id: RouteId;

L'ID de la route courante – par ex. /blog/[slug] pour la route src/routes/blog/[slug]

ts
url: URL;

L'URL de la page courante

NavigationTarget

Des informations sur la cible d'une navigation.

ts
interface NavigationTarget {}
ts
params: Record<string, string> | null;

Les paramètres de la page cible – pax ex. un objet { slug: string } pour la route /blog/[slug]. Vaut null si la cible ne fait pas partie de votre application SvelteKit (car ne correspond à aucune de vos routes).

ts
route: { id: string | null };

Des informations sur la route cible

ts
url: URL;

L'URL vers laquelle la navigation se dirige

NavigationType

  • enter: L'application a été hydratée
  • form: Un élément <form> a été soumis avec une méthode GET
  • leave: L'utilisateur ou utilisatrice quitte l'application en fermant l'onglet ou en utilisant les boutons retour/suivant du navigateur pour aller sur un document différent
  • link: La navigation a été déclenchée par un clic sur un lien
  • goto: La navigation a été déclenchée par un appel à goto(...) ou une redirection
  • popstate: La navigation a été déclenchée par une navigation avec les boutons retour/suivant du navigateur
ts
type NavigationType =
| 'enter'
| 'form'
| 'leave'
| 'link'
| 'goto'
| 'popstate';

NumericRange

ts
type NumericRange<
TStart extends number,
TEnd extends number
> = Exclude<TEnd | LessThan<TEnd>, LessThan<TStart>>;

OnNavigate

L'argument passé aux callbacks onNavigate.

ts
interface OnNavigate extends Navigation {}
ts
type: Exclude<NavigationType, 'enter' | 'leave'>;

Le type de navigation :

  • form: L'utilisateur ou utilisatrice a soumis un <form>
  • link: La navigation a été déclenchée par un clic sur un lien
  • goto: La navigation a été déclenchée par un appel à goto(...) ou une redirection
  • popstate: La navigation a été déclenchée par les boutons précédent/suivant du navigateur
ts
willUnload: false;

Puisque les callbacks onNavigate sont exécutés immédiatement avant une navigation côté client, ils ne seront jamais appelés lorsqu'une navigation décharge la page.

Page

La forme du store $page

ts
interface Page<
Params extends Record<string, string> = Record<
string,
string
>,
RouteId extends string | null = string | null
> {}
ts
url: URL;

L'URL de la page courante

ts
params: Params;

Les paramètres de la page courante – par ex. un objet { slug: string } pour la route /blog/[slug]

ts
route: {}

Des informations sur la route courante

ts
id: RouteId;

L'ID de la route courante – par ex. /blog/[slug] pour la route src/routes/blog/[slug]

ts
status: number;

Le code de statut HTTP pour la page courante

ts
error: App.Error | null;

L'objet d'erreur pour la page courante, si pertinent. Rempli grâce aux hooks handleError.

ts
data: App.PageData & Record<string, any>;

Le résultat de la fusion de toutes les données renvoyées par toutes les fonctions load de la page courante. Vous pouvez typer un dénominateur commun grâce à App.PageData.

ts
state: App.PageState;

L'état de la page, qui peut être manipulé avec les fonctions pushState et replaceState importées depuis $app/navigation.

ts
form: any;

Rempli uniquement après la soumission d'un formulaire. Voir la section sur les actions de formulaire pour plus d'informations.

ParamMatcher

La forme d'une fonction match. Voir la section sur les fonctions match pour plus d'informations.

ts
type ParamMatcher = (param: string) => boolean;

PrerenderOption

ts
type PrerenderOption = boolean | 'auto';

Redirect

L'objet renvoyé par la fonction redirect

ts
interface Redirect {}
ts
status: 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308;

Le code représentant le statut HTTP, entre 400 et 599.

ts
location: string;

L'emplacement vers lequel rediriger.

RequestEvent

ts
interface RequestEvent<
Params extends Partial<Record<string, string>> = Partial<
Record<string, string>
>,
RouteId extends string | null = string | null
> {}
ts
cookies: Cookies;

Définit ou récupère les cookies liés à la requête courante

ts
fetch: typeof fetch;

La méthode fetch est équivalente à l'API web native fetch, avec quelques fonctionnalités additionnelles :

  • Vous pouvez l'utiliser pour faire des requêtes authentifiées sur le serveur, puisqu'elle hérite des headers cookie et authorization de la requête de page.
  • Elle peut faire des requêtes relatives sur votre serveur (d'habitude, fetch nécessite une URL avec une origine lorsqu'utilisée dans un contexte serveur).
  • Les requêtes internes (par ex. vers des routes +server.js) vont directement vers la fonction concernée si fetch est exécutée sur le serveur, sans la surcharge d'une requête HTTP.
  • Pendant le rendu côté serveur, la réponse est capturée et inlinée dans le HTML rendu en utilisant les méthodes text et json de l'objet Response. Notez que les headers ne seront pas sérialisés, à moins d'être inclus explicitement via filterSerializedResponseHeaders
  • Pendant l'hydratation, la réponse est lue depuis le HTML, en garantissant la cohérence et évitant une requête réseau supplémentaire.

Vous pouvez en apprendre plus sur les requêtes authentifiées avec cookies ici.

ts
getClientAddress(): string;

L'adresse IP du client, définie par l'adaptateur.

ts
locals: App.Locals;

Contient les données personnalisées qui ont été ajoutées à la requête via le hook handle.

ts
params: Params;

Les paramètres de la route courante – par ex. un objet { slug: string } pour la route /blog/[slug].

ts
platform: Readonly<App.Platform> | undefined;

Des données supplémentaire rendues disponibles via l'adaptateur.

ts
request: Request;

L'objet de la requête originale.

ts
route: {}

Des informations sur la route courante.

ts
id: RouteId;

L'ID de la route courante – par ex. /blog/[slug] pour la route src/routes/blog/[slug]

ts
setHeaders(headers: Record<string, string>): void;

Si vous avez besoin de définir des headers de réponse, vous pouvez le faire en utilisant cette méthode. Cela est utile si vous souhaitez changer la page à mettre en cache, par exemple :

src/routes/blog/+page.js
ts
export async function load({ fetch, setHeaders }) {
Binding element 'fetch' implicitly has an 'any' type.
Binding element 'setHeaders' implicitly has an 'any' type.
7031
7031
Binding element 'fetch' implicitly has an 'any' type.
Binding element 'setHeaders' implicitly has an 'any' type.
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();
}
src/routes/blog/+page.ts
ts
export async function load({ fetch, setHeaders }) {
Binding element 'fetch' implicitly has an 'any' type.
Binding element 'setHeaders' implicitly has an 'any' type.
7031
7031
Binding element 'fetch' implicitly has an 'any' type.
Binding element 'setHeaders' implicitly has an 'any' type.
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();
}

Définir le même header plusieurs fois (même dans des fonctions load différentes) est une erreur – vous pouvez définir un header donné seulement une seule fois.

Vous ne pouvez pas ajouter un header set-cookie en même temps que vous utilisez setHeaders – utilisez plutôt l'API cookies dans une fonction load de serveur.

ts
url: URL;

L'URL demandée.

ts
isDataRequest: boolean;

Vaut true si la requête vient du client demandant les données de +page/layout.server.js. La propriété url ne contiendra pas dans ce cas les informations internes liées à la requête de données. Utilisez cette propriété si cette distinction est importante pour vous.

ts
isSubRequest: boolean;

Vaut true pour les requêtes +server.js venant de SvelteKit sans avoir généré de requête HTTP au sens propre. Ceci se produit lorsque vous faites depuis le serveur des requêtes fetch venant de la même origine.

RequestHandler

Une fonction (event: RequestEvent) => Response exportée depuis un fichier +server.js et correspondant à un verbe HTTP (GET, PUT, PATCH, etc), permettant de gérer les requêtes avec cette méthode.

Elle reçoit un objet Params comme type par défaut du premier argument, ce que vous pouvez éviter en utilisant plutôt des types générés.

ts
type RequestHandler<
Params extends Partial<Record<string, string>> = Partial<
Record<string, string>
>,
RouteId extends string | null = string | null
> = (
event: RequestEvent<Params, RouteId>
) => MaybePromise<Response>;

Reroute

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

ts
type Reroute = (event: { url: URL }) => void | string;

ResolveOptions

ts
interface ResolveOptions {}
ts
transformPageChunk?(input: { html: string; done: boolean }): MaybePromise<string | undefined>;
  • input le morceau de HTML et l'information de s'il s'agit du dernier morceau

Applique des transformations personnalisées au HTML. Si done vaut true, il s'agit du dernier morceau (chunk) de HTML. Les morceaux ne sont pas forcément du HTML bien formé (ils peuvent inclure la balise ouvrante d'un élément mais pas la balise fermante, par exemple), mais ils seront toujours découpés en fonctions de frontières sensibles, comme %sveltekit.head% ou les composants de page ou de layout.

ts
filterSerializedResponseHeaders?(name: string, value: string): boolean;
  • name nom du header
  • value valeur du header

Détermine quels headers doivent être inclus dans les réponses sérialisées lorsqu'une fonction load charge une ressource avec fetch. Par défaut, aucun ne sera inclus.

ts
preload?(input: { type: 'font' | 'css' | 'js' | 'asset'; path: string }): boolean;
  • input le type de fichier et son chemin

Détermine quels fichiers doivent être ajoutés à la balise <head> pour les précharger. Par défaut, les fichiers js et css seront préchargés.

RouteDefinition

ts
interface RouteDefinition<Config = any> {}
ts
id: string;
ts
api: {
methods: Array<HttpMethod | '*'>;
};
ts
page: {
methods: Array<Extract<HttpMethod, 'GET' | 'POST'>>;
};
ts
pattern: RegExp;
ts
prerender: PrerenderOption;
ts
segments: RouteSegment[];
ts
methods: Array<HttpMethod | '*'>;
ts
config: Config;

SSRManifest

ts
interface SSRManifest {}
ts
appDir: string;
ts
appPath: string;
ts
assets: Set<string>;
ts
mimeTypes: Record<string, string>;
ts
_: {}

propriétés privées

ts
client: NonNullable<BuildData['client']>;
ts
nodes: SSRNodeLoader[];
ts
routes: SSRRoute[];
ts
matchers(): Promise<Record<string, ParamMatcher>>;
ts
server_assets: Record<string, number>;

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

Server

ts
class Server {}
ts
constructor(manifest: SSRManifest);
ts
init(options: ServerInitOptions): Promise<void>;
ts
respond(request: Request, options: RequestOptions): Promise<Response>;

ServerInitOptions

ts
interface ServerInitOptions {}
ts
env: Record<string, string>;

A map of environment variables

ts
read?: (file: string) => ReadableStream;

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

ServerLoad

La forme générique de PageServerLoad et LayoutServerLoad. Vous devriez importer ces derniers depuis ./$types (voir la section Types générés) plutôt que d'utiliser ServerEvent directement.

ts
type ServerLoad<
Params extends Partial<Record<string, string>> = Partial<
Record<string, string>
>,
ParentData extends Record<string, any> = Record<
string,
any
>,
OutputData extends Record<string, any> | void = Record<
string,
any
> | void,
RouteId extends string | null = string | null
> = (
event: ServerLoadEvent<Params, ParentData, RouteId>
) => MaybePromise<OutputData>;

ServerLoadEvent

ts
interface ServerLoadEvent<
Params extends Partial<Record<string, string>> = Partial<
Record<string, string>
>,
ParentData extends Record<string, any> = Record<
string,
any
>,
RouteId extends string | null = string | null
> extends RequestEvent<Params, RouteId> {}
ts
parent(): Promise<ParentData>;

await parent() renvoie les données des fonctions load des fichiers +layout.server.js parents.

Faites attention à ne pas introduire de "cascade" de chargement accidentelle lorsque vous utilisez await parent(). Si par exemple vous voulez uniquement fusionner les données du parent dans un objet à renvoyer, appelez cette fonction après avoir téléchargé vos autres données.

ts
depends(...deps: string[]): void;

Cette fonction déclare que la fonction load a comme dépendances une ou plusieurs URLs ou identifiants personnalisés, qui peuvent donc être utilisés avec invalidate() pour déclencher la réexécution de la méthode load.

La plupart du temps vous n'avez pas besoin d'utiliser ceci, puisque fetch appelle depends pour vous – c'est uniquement nécessaire si vous utilisez un client d'API personnalisé qui contourne fetch.

Les URLs peuvent être absolues ou relatives à la page qui est en train d'être chargée, et doivent être encodées.

Les identifiants personnaliés doivent être préfixés avec une ou plusieurs lettres en minuscules suivies d'un : pour satisfaire la spécification URI.

L'exemple suivant vous montre comment utiliser depends pour déclarer une dépendance à un identifiant personnalisé, qui sera invalidé avec invalidate après un clic sur un bouton, déclenchant la réexécution de la fonction load.

src/routes/+page.js
ts
let count = 0;
export async function load({ depends }) {
Binding element 'depends' implicitly has an 'any' type.7031Binding element 'depends' implicitly has an 'any' type.
depends('increase:count');
return { count: count++ };
}
src/routes/+page.ts
ts
let count = 0;
export async function load({ depends }) {
Binding element 'depends' implicitly has an 'any' type.7031Binding element 'depends' implicitly has an 'any' type.
depends('increase:count');
return { count: count++ };
}
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}>Augmenter le compteur</button>
ts
untrack<T>(fn: () => T): T;

Use this function to opt out of dependency tracking for everything that is synchronously called within the callback. Example:

src/routes/+page.js
ts
export async function load({ untrack, url }) {
Binding element 'untrack' implicitly has an 'any' type.
Binding element 'url' implicitly has an 'any' type.
7031
7031
Binding element 'untrack' implicitly has an 'any' type.
Binding element 'url' implicitly has an 'any' type.
// Untrack url.pathname so that path changes don't trigger a rerun
if (untrack(() => url.pathname === '/')) {
return { message: 'Welcome!' };
}
}
src/routes/+page.ts
ts
export async function load({ untrack, url }) {
Binding element 'untrack' implicitly has an 'any' type.
Binding element 'url' implicitly has an 'any' type.
7031
7031
Binding element 'untrack' implicitly has an 'any' type.
Binding element 'url' implicitly has an 'any' type.
// Untrack url.pathname so that path changes don't trigger a rerun
if (untrack(() => url.pathname === '/')) {
return { message: 'Welcome!' };
}
}

Snapshot

Le type de la variable export const snapshot exportée d'un composant de page ou de layout.

ts
interface Snapshot<T = any> {}
ts
capture: () => T;
ts
restore: (snapshot: T) => void;

SubmitFunction

ts
type SubmitFunction<
Success extends
| Record<string, unknown>
| undefined = Record<string, any>,
Failure extends
| Record<string, unknown>
| undefined = Record<string, any>
> = (input: {
action: URL;
formData: FormData;
formElement: HTMLFormElement;
controller: AbortController;
submitter: HTMLElement | null;
cancel(): void;
}) => MaybePromise<
| void
| ((opts: {
formData: FormData;
formElement: HTMLFormElement;
action: URL;
result: ActionResult<Success, Failure>;
/**
* Appelez cette fonction pour récupérer le comportement par défaut d'une soumission de formulaire.
* @param options Définissez `reset: false` si vous ne souhaitez pas que les valeurs de l'élément `<form>` soient réinitialisées si la soumission du formulaire s'est bien passée.
*/
update(options?: {
reset?: boolean;
invalidateAll?: boolean;
}): Promise<void>;
}) => void)
>;

Private types

Les types suivants sont référencés par les types publics documentés ci-dessus, mais ne peuvent pas être directement importés :

AdapterEntry

ts
interface AdapterEntry {}
ts
id: string;

Une chaîne de caractères qui identifie de manière unique un service HTTP (par exemple une fonction serverless) et utile pour dédoublonner. Par exemple, /foo/a-[b] et /foo/[c] sont des routes différentes, mais sont toutes deux représentées par /foo/:param dans un fichier Netlify _redirects, et partagent donc un ID.

ts
filter(route: RouteDefinition): boolean;

Une fonction qui compare la route candidate avec la route courante pour déterminer si elle devrait être groupée avec la route courante.

Cas d'usage :

  • Pages de repli : /foo/[c] is une solution de repli pour /foo/a-[b], et /[...catchall] est une solution de repli pour toutes les routes
  • Grouper les routes qui partagent une config commune : /foo devraient être déployée sur le réseau edge, /bar et /baz devraient être déployées sur une fonction serverless
ts
complete(entry: { generateManifest(opts: { relativePath: string }): string }): MaybePromise<void>;

Une fonction qui est invoquée une fois que l'entrée a été créée. C'est ici que vous devriez écrire la fonction dans le système de fichiers et générer les manifestes de redirections.

Csp

ts
namespace Csp {
type ActionSource = 'strict-dynamic' | 'report-sample';
type BaseSource =
| 'self'
| 'unsafe-eval'
| 'unsafe-hashes'
| 'unsafe-inline'
| 'wasm-unsafe-eval'
| 'none';
type CryptoSource =
`${'nonce' | 'sha256' | 'sha384' | 'sha512'}-${string}`;
type FrameSource =
| HostSource
| SchemeSource
| 'self'
| 'none';
type HostNameScheme = `${string}.${string}` | 'localhost';
type HostSource =
`${HostProtocolSchemes}${HostNameScheme}${PortScheme}`;
type HostProtocolSchemes = `${string}://` | '';
type HttpDelineator = '/' | '?' | '#' | '\\';
type PortScheme = `:${number}` | '' | ':*';
type SchemeSource =
| 'http:'
| 'https:'
| 'data:'
| 'mediastream:'
| 'blob:'
| 'filesystem:';
type Source =
| HostSource
| SchemeSource
| CryptoSource
| BaseSource;
type Sources = Source[];
type UriPath = `${HttpDelineator}${string}`;
}

CspDirectives

ts
interface CspDirectives {}
ts
'child-src'?: Csp.Sources;
ts
'default-src'?: Array<Csp.Source | Csp.ActionSource>;
ts
'frame-src'?: Csp.Sources;
ts
'worker-src'?: Csp.Sources;
ts
'connect-src'?: Csp.Sources;
ts
'font-src'?: Csp.Sources;
ts
'img-src'?: Csp.Sources;
ts
'manifest-src'?: Csp.Sources;
ts
'media-src'?: Csp.Sources;
ts
'object-src'?: Csp.Sources;
ts
'prefetch-src'?: Csp.Sources;
ts
'script-src'?: Array<Csp.Source | Csp.ActionSource>;
ts
'script-src-elem'?: Csp.Sources;
ts
'script-src-attr'?: Csp.Sources;
ts
'style-src'?: Array<Csp.Source | Csp.ActionSource>;
ts
'style-src-elem'?: Csp.Sources;
ts
'style-src-attr'?: Csp.Sources;
ts
'base-uri'?: Array<Csp.Source | Csp.ActionSource>;
ts
sandbox?: Array<
| 'allow-downloads-without-user-activation'
| 'allow-forms'
| 'allow-modals'
| 'allow-orientation-lock'
| 'allow-pointer-lock'
| 'allow-popups'
| 'allow-popups-to-escape-sandbox'
| 'allow-presentation'
| 'allow-same-origin'
| 'allow-scripts'
| 'allow-storage-access-by-user-activation'
| 'allow-top-navigation'
| 'allow-top-navigation-by-user-activation'
>;
ts
'form-action'?: Array<Csp.Source | Csp.ActionSource>;
ts
'frame-ancestors'?: Array<Csp.HostSource | Csp.SchemeSource | Csp.FrameSource>;
ts
'navigate-to'?: Array<Csp.Source | Csp.ActionSource>;
ts
'report-uri'?: Csp.UriPath[];
ts
'report-to'?: string[];
ts
'require-trusted-types-for'?: Array<'script'>;
ts
'trusted-types'?: Array<'none' | 'allow-duplicates' | '*' | string>;
ts
'upgrade-insecure-requests'?: boolean;
ts
'require-sri-for'?: Array<'script' | 'style' | 'script style'>;
  • déprécié undefined
ts
'block-all-mixed-content'?: boolean;
  • déprécié undefined
ts
'plugin-types'?: Array<`${string}/${string}` | 'none'>;
  • déprécié undefined
ts
referrer?: Array<
| 'no-referrer'
| 'no-referrer-when-downgrade'
| 'origin'
| 'origin-when-cross-origin'
| 'same-origin'
| 'strict-origin'
| 'strict-origin-when-cross-origin'
| 'unsafe-url'
| 'none'
>;
  • déprécié undefined

HttpMethod

ts
type HttpMethod =
| 'GET'
| 'HEAD'
| 'POST'
| 'PUT'
| 'DELETE'
| 'PATCH'
| 'OPTIONS';

Logger

ts
interface Logger {}
ts
(msg: string): void;
ts
success(msg: string): void;
ts
error(msg: string): void;
ts
warn(msg: string): void;
ts
minor(msg: string): void;
ts
info(msg: string): void;

MaybePromise

ts
type MaybePromise<T> = T | Promise<T>;

PrerenderEntryGeneratorMismatchHandler

ts
interface PrerenderEntryGeneratorMismatchHandler {}
ts
(details: { generatedFromId: string; entry: string; matchedId: string; message: string }): void;

PrerenderEntryGeneratorMismatchHandlerValue

ts
type PrerenderEntryGeneratorMismatchHandlerValue =
| 'fail'
| 'warn'
| 'ignore'
| PrerenderEntryGeneratorMismatchHandler;

PrerenderHttpErrorHandler

ts
interface PrerenderHttpErrorHandler {}
ts
(details: {
status: number;
path: string;
referrer: string | null;
referenceType: 'linked' | 'fetched';
message: string;
}): void;

PrerenderHttpErrorHandlerValue

ts
type PrerenderHttpErrorHandlerValue =
| 'fail'
| 'warn'
| 'ignore'
| PrerenderHttpErrorHandler;

PrerenderMap

ts
type PrerenderMap = Map<string, PrerenderOption>;

PrerenderMissingIdHandler

ts
interface PrerenderMissingIdHandler {}
ts
(details: { path: string; id: string; referrers: string[]; message: string }): void;

PrerenderMissingIdHandlerValue

ts
type PrerenderMissingIdHandlerValue =
| 'fail'
| 'warn'
| 'ignore'
| PrerenderMissingIdHandler;

PrerenderOption

ts
type PrerenderOption = boolean | 'auto';

Prerendered

ts
interface Prerendered {}
ts
pages: Map<
string,
{
/** L'emplacement du fichier `.html`, relatif au dossier de compilation */
file: string;
}
>;

Un dictionnaire de path vers des objets { file }, où un chemin comme /foo correspond à foo.html et un chemin comme /bar/ correspond à bar/index.html.

ts
assets: Map<
string,
{
/** Le type <span class='vo'>[MIME](https://sveltefr.dev/docs/web#mime)</span> du fichier statique */
type: string;
}
>;

Un dictionnaire de path vers des objets { type }

ts
redirects: Map<
string,
{
status: number;
location: string;
}
>;

Un dictionnaire de redirections rencontrées durant le prérendu.

ts
paths: string[];

Un tableau de chemins prérendus (sans les trailing slashs, peu importe la configuration de trailing slash)

RequestOptions

ts
interface RequestOptions {}
ts
getClientAddress(): string;
ts
platform?: App.Platform;

RouteSegment

ts
interface RouteSegment {}
ts
content: string;
ts
dynamic: boolean;
ts
rest: boolean;

TrailingSlash

ts
type TrailingSlash = 'never' | 'always' | 'ignore';

Generated types

Les types RequestHandler et Load acceptent tous les deux un argument Params vous permettant de typer l'objet params. Par exemple, ce endpoint attend les paramètres foo, bar, et baz :

src/routes/[foo]/[bar]/[baz]/+page.server.js
ts
/** @type {import('@sveltejs/kit').RequestHandler<{
foo: string;
bar: string;
baz: string
}>} */
export async function GET({ params }) {
A function whose declared type is neither 'void' nor 'any' must return a value.2355A function whose declared type is neither 'void' nor 'any' must return a value.
// ...
}
src/routes/[foo]/[bar]/[baz]/+page.server.ts
ts
export const GET: import('@sveltejs/kit').RequestHandler<{
Type '({ params }: RequestEvent<{ foo: string; bar: string; baz: string; }, string | null>) => Promise<void>' is not assignable to type 'RequestHandler<{ foo: string; bar: string; baz: string; }, string | null>'. Type 'Promise<void>' is not assignable to type 'MaybePromise<Response>'. Type 'Promise<void>' is not assignable to type 'Promise<Response>'. Type 'void' is not assignable to type 'Response'.2322Type '({ params }: RequestEvent<{ foo: string; bar: string; baz: string; }, string | null>) => Promise<void>' is not assignable to type 'RequestHandler<{ foo: string; bar: string; baz: string; }, string | null>'. Type 'Promise<void>' is not assignable to type 'MaybePromise<Response>'. Type 'Promise<void>' is not assignable to type 'Promise<Response>'. Type 'void' is not assignable to type 'Response'.
foo: string;
bar: string;
baz: string;
}> = async ({ params }) => {
// ...
};

Il est évident que ceci est lourd à écrire, et peu versatile (si vous êtes amené•e à renommer le dossier [foo] en [qux], le type ne reflèterait plus la réalité).

Pour résoudre ce problème, SvelteKit génère des fichiers .d.ts pour chacun de vos endpoints et chacune de vos pages :

.svelte-kit/types/src/routes/[foo]/[bar]/[baz]/$types.d.ts
ts
import type * as Kit from '@sveltejs/kit';
type RouteParams = {
foo: string;
bar: string;
baz: string;
}
export type PageServerLoad = Kit.ServerLoad<RouteParams>;
export type PageLoad = Kit.Load<RouteParams>;

Ces types peuvent être importés dans vos endpoints et pages comme s'ils appartenaient au même dossier, grâce à l'option rootDirs de votre configuration TypeScript :

src/routes/[foo]/[bar]/[baz]/+page.server.js
ts
/** @type {import('./$types').PageServerLoad} */
export async function GET({ params }) {
// ...
}
src/routes/[foo]/[bar]/[baz]/+page.server.ts
ts
import type { PageServerLoad } from './$types';
export const GET: PageServerLoad = async ({ params }) => {
// ...
};
src/routes/[foo]/[bar]/[baz]/+page.js
ts
/** @type {import('./$types').PageLoad} */
export async function load({ params, fetch }) {
// ...
}
src/routes/[foo]/[bar]/[baz]/+page.ts
ts
import type { PageLoad } from './$types';
export const load: PageLoad = async ({ params, fetch }) => {
// ...
};

Pour que ceci fonctionne, votre propre fichier tsconfig.json ou jsconfig.json doit étendre le fichier .svelte-kit/tsconfig.json que SvelteKit génère (où .svelte-kit est votre outDir) :

{ "extends": "./.svelte-kit/tsconfig.json" }

tsconfig.json par défaut

Le fichier généré .svelte-kit/tsconfig.json contient un mélange d'options. Certaines sont générées programmatiquement en fonction de votre configuration de projet, et ne devraient pas être redéfinies sans une bonne raison :

.svelte-kit/tsconfig.json
ts
{
"compilerOptions": {
"baseUrl": "..",
"paths": {
"$lib": "src/lib",
"$lib/*": "src/lib/*"
},
"rootDirs": ["..", "./types"]
},
"include": ["../src/**/*.js", "../src/**/*.ts", "../src/**/*.svelte"],
"exclude": ["../node_modules/**", "./**"]
}

D'autres sont requises pour que SvelteKit fonctionne correctement, et devraient également être laissées telles quelles sauf si vous savez ce que vous faites :

.svelte-kit/tsconfig.json
ts
{
"compilerOptions": {
// ceci assure que les types sont explicitement
// importés avec `import type`, ce qui est
// nécessaire car sinon `svelte-preprocess`
// ne peut pas compiler les composants correctement
"importsNotUsedAsValues": "error",
// Vite compile un module TypeScript à la fois,
// plutôt que de compiler le graph entier de modules
"isolatedModules": true,
// TypeSCript ne peut pas "voir" lorsque
// vous utilisez une valeur importée dans votre markup,
// nous avons donc besoin de ceci
"preserveValueImports": true,
// Ceci assure que `vite build` et `svelte-package`
// fonctionnent correctement
"lib": ["esnext", "DOM", "DOM.Iterable"],
"moduleResolution": "node",
"module": "esnext",
"target": "esnext"
}
}

App

Error

Définit la forme commune des erreurs attendues et inattendues. Les erreurs attendues sont levées en utilisant la fonction error. Les erreurs inattendues sont gérées par le hook handleError qui doit renvoyer cette forme.

ts
interface Error {}
ts
message: string;

Locals

L'interface qui définit event.locals, qui est accessible dans les hooks (handle, et handleError), les fonctions load de serveur, et les fichiers +server.js.

ts
interface Locals {}

PageData

Définit la forme commune du store $page.data - c'est-à-dire les données qui sont partagées entre toutes les pages. Les types des fonctions Load et ServerLoad dans ./$types seront affinés en fonction. Utilisez des propriétés optionnelles pour des données uniquement présentes dans certaines pages. N'ajoutez pas de signature d'indice ([key: string]: any).

ts
interface PageData {}

PageState

Le type de l'objet $page.state, qui peut être manipulé avec les fonctions pushState et replaceState importées depuis $app/navigation.

ts
interface PageState {}

Platform

Si votre adaptateur fournit un contexte spécifique à sa plateforme via event.platform, vous pouvez le spécifier ici.

ts
interface Platform {}
précédent Modules