Référence
Types
Éditer cette page sur GithubPublic typespermalink
Les types suivants peuvent être importés depuis @sveltejs/kit
:
Actionpermalink
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>;
ActionFailurepermalink
ts
interface ActionFailure<T extends Record<string, unknown> | undefined = undefined> {…}
ts
status: number;
ts
data: T;
ts
[uniqueSymbol]: true;
ActionResultpermalink
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 };
Actionspermalink
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>>;
Adapterpermalink
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
AfterNavigatepermalink
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éeform
: L'utilisateur ou utilisatrice a soumis un<form>
link
: La navigation a été déclenchée par un clic sur un liengoto
: La navigation a été déclenchée par un appel àgoto(...)
ou une redirectionpopstate
: 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.
AwaitedActionspermalink
ts
type AwaitedActions<T extends Record<string, (...args: any) => any>> = OptionalUnion<{[Key in keyof T]: UnpackValidationError<Awaited<ReturnType<T[Key]>>>;}[keyof T]>;
BeforeNavigatepermalink
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.
Builderpermalink
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 sourceto
le fichier ou dossier de destinationopts.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.
Configpermalink
ts
interface Config {…}
See the configuration reference for details.
Cookiespermalink
ts
interface Cookies {…}
ts
get(name: string, opts?: import('cookie').CookieParseOptions): string | undefined;
name
le nom du cookieopts
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 cookievalue
la valeur du cookieopts
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 cookieopts
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 cookievalue
la valeur du cookieopts
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
Emulatorpermalink
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
Handlepermalink
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>;
HandleClientErrorpermalink
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>;
HandleFetchpermalink
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>;
HandleServerErrorpermalink
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>;
HttpErrorpermalink
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.
KitConfigpermalink
ts
interface KitConfig {…}
See the configuration reference for details.
LessThanpermalink
ts
type LessThan<TNumber extends number,TArray extends any[] = []> = TNumber extends TArray['length']? TArray[number]: LessThan<TNumber, [...TArray, TArray['length']]>;
Loadpermalink
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>;
LoadEventpermalink
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
etauthorization
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 sifetch
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
etjson
de l'objetResponse
. Notez que les headers ne seront pas sérialisés, à moins d'être inclus explicitement viafilterSerializedResponseHeaders
- 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 :
ts
export async functionBinding element 'fetch' implicitly has an 'any' type.Binding element 'setHeaders' implicitly has an 'any' type.7031load ({, fetch }) { setHeaders
7031Binding element 'fetch' implicitly has an 'any' type.Binding element 'setHeaders' implicitly has an 'any' type.consturl = `https://cms.example.com/articles.json`;constresponse = awaitfetch (url );setHeaders ({age :response .headers .get ('age'),'cache-control':response .headers .get ('cache-control')});returnresponse .json ();}
ts
export async functionBinding element 'fetch' implicitly has an 'any' type.Binding element 'setHeaders' implicitly has an 'any' type.7031load ({, fetch }) { setHeaders
7031Binding element 'fetch' implicitly has an 'any' type.Binding element 'setHeaders' implicitly has an 'any' type.consturl = `https://cms.example.com/articles.json`;constresponse = awaitfetch (url );setHeaders ({age :response .headers .get ('age'),'cache-control':response .headers .get ('cache-control'),});returnresponse .json ();}
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
.
ts
letcount = 0;export async functionBinding element 'depends' implicitly has an 'any' type.7031Binding element 'depends' implicitly has an 'any' type.load ({}) { depends depends ('increase:count');return {count :count ++ };}
ts
letcount = 0;export async functionBinding element 'depends' implicitly has an 'any' type.7031Binding element 'depends' implicitly has an 'any' type.load ({}) { depends depends ('increase:count');return {count :count ++ };}
<script>
import { invalidate } from '$app/navigation';
export let data;
const increase = async () => {
await invalidate('increase:count');
}
</script>
<p>{data.count}<p>
<button on:click={increase}>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:
ts
export async functionBinding element 'untrack' implicitly has an 'any' type.Binding element 'url' implicitly has an 'any' type.7031load ({, untrack }) { url
7031Binding 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 rerunif (untrack (() =>url .pathname === '/')) {return {message : 'Welcome!' };}}
ts
export async functionBinding element 'untrack' implicitly has an 'any' type.Binding element 'url' implicitly has an 'any' type.7031load ({, untrack }) { url
7031Binding 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 rerunif (untrack (() =>url .pathname === '/')) {return {message : 'Welcome!' };}}
LoadPropertiespermalink
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;
Navigationpermalink
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é soumisleave
: L'utilisateur ou utilisatrice quitte l'application en fermant l'onglet ou en naviguant vers un document différentlink
: La navigation a été déclenchée par un clic sur un liengoto
: La navigation a été déclenchée par un appel àgoto(...)
ou une redirectionpopstate
: 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
NavigationEventpermalink
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
NavigationTargetpermalink
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
NavigationTypepermalink
enter
: L'application a été hydratéeform
: Un élément<form>
a été soumis avec une méthode GETleave
: 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érentlink
: La navigation a été déclenchée par un clic sur un liengoto
: La navigation a été déclenchée par un appel àgoto(...)
ou une redirectionpopstate
: 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';
NumericRangepermalink
ts
type NumericRange<TStart extends number,TEnd extends number> = Exclude<TEnd | LessThan<TEnd>, LessThan<TStart>>;
OnNavigatepermalink
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 liengoto
: La navigation a été déclenchée par un appel àgoto(...)
ou une redirectionpopstate
: 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.
Pagepermalink
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.
ParamMatcherpermalink
La forme d'une fonction match
. Voir la section sur les fonctions match
pour plus d'informations.
ts
type ParamMatcher = (param: string) => boolean;
PrerenderOptionpermalink
ts
type PrerenderOption = boolean | 'auto';
Redirectpermalink
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.
RequestEventpermalink
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
etauthorization
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 sifetch
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
etjson
de l'objetResponse
. Notez que les headers ne seront pas sérialisés, à moins d'être inclus explicitement viafilterSerializedResponseHeaders
- 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 :
ts
export async functionBinding element 'fetch' implicitly has an 'any' type.Binding element 'setHeaders' implicitly has an 'any' type.7031load ({, fetch }) { setHeaders
7031Binding element 'fetch' implicitly has an 'any' type.Binding element 'setHeaders' implicitly has an 'any' type.consturl = `https://cms.example.com/articles.json`;constresponse = awaitfetch (url );setHeaders ({age :response .headers .get ('age'),'cache-control':response .headers .get ('cache-control')});returnresponse .json ();}
ts
export async functionBinding element 'fetch' implicitly has an 'any' type.Binding element 'setHeaders' implicitly has an 'any' type.7031load ({, fetch }) { setHeaders
7031Binding element 'fetch' implicitly has an 'any' type.Binding element 'setHeaders' implicitly has an 'any' type.consturl = `https://cms.example.com/articles.json`;constresponse = awaitfetch (url );setHeaders ({age :response .headers .get ('age'),'cache-control':response .headers .get ('cache-control'),});returnresponse .json ();}
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.
RequestHandlerpermalink
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>;
Reroutepermalink
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;
ResolveOptionspermalink
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 headervalue
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.
RouteDefinitionpermalink
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;
SSRManifestpermalink
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
Serverpermalink
ts
class Server {…}
ts
constructor(manifest: SSRManifest);
ts
init(options: ServerInitOptions): Promise<void>;
ts
respond(request: Request, options: RequestOptions): Promise<Response>;
ServerInitOptionspermalink
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
ServerLoadpermalink
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>;
ServerLoadEventpermalink
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
.
ts
letcount = 0;export async functionBinding element 'depends' implicitly has an 'any' type.7031Binding element 'depends' implicitly has an 'any' type.load ({}) { depends depends ('increase:count');return {count :count ++ };}
ts
letcount = 0;export async functionBinding element 'depends' implicitly has an 'any' type.7031Binding element 'depends' implicitly has an 'any' type.load ({}) { depends depends ('increase:count');return {count :count ++ };}
<script>
import { invalidate } from '$app/navigation';
export let data;
const increase = async () => {
await invalidate('increase:count');
}
</script>
<p>{data.count}<p>
<button on:click={increase}>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:
ts
export async functionBinding element 'untrack' implicitly has an 'any' type.Binding element 'url' implicitly has an 'any' type.7031load ({, untrack }) { url
7031Binding 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 rerunif (untrack (() =>url .pathname === '/')) {return {message : 'Welcome!' };}}
ts
export async functionBinding element 'untrack' implicitly has an 'any' type.Binding element 'url' implicitly has an 'any' type.7031load ({, untrack }) { url
7031Binding 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 rerunif (untrack (() =>url .pathname === '/')) {return {message : 'Welcome!' };}}
Snapshotpermalink
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;
SubmitFunctionpermalink
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 typespermalink
Les types suivants sont référencés par les types publics documentés ci-dessus, mais ne peuvent pas être directement importés :
AdapterEntrypermalink
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.
Csppermalink
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}`;}
CspDirectivespermalink
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
HttpMethodpermalink
ts
type HttpMethod =| 'GET'| 'HEAD'| 'POST'| 'PUT'| 'DELETE'| 'PATCH'| 'OPTIONS';
Loggerpermalink
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;
MaybePromisepermalink
ts
type MaybePromise<T> = T | Promise<T>;
PrerenderEntryGeneratorMismatchHandlerpermalink
ts
interface PrerenderEntryGeneratorMismatchHandler {…}
ts
(details: { generatedFromId: string; entry: string; matchedId: string; message: string }): void;
PrerenderEntryGeneratorMismatchHandlerValuepermalink
ts
type PrerenderEntryGeneratorMismatchHandlerValue =| 'fail'| 'warn'| 'ignore'| PrerenderEntryGeneratorMismatchHandler;
PrerenderHttpErrorHandlerpermalink
ts
interface PrerenderHttpErrorHandler {…}
ts
(details: {status: number;path: string;referrer: string | null;referenceType: 'linked' | 'fetched';message: string;}): void;
PrerenderHttpErrorHandlerValuepermalink
ts
type PrerenderHttpErrorHandlerValue =| 'fail'| 'warn'| 'ignore'| PrerenderHttpErrorHandler;
PrerenderMappermalink
ts
type PrerenderMap = Map<string, PrerenderOption>;
PrerenderMissingIdHandlerpermalink
ts
interface PrerenderMissingIdHandler {…}
ts
(details: { path: string; id: string; referrers: string[]; message: string }): void;
PrerenderMissingIdHandlerValuepermalink
ts
type PrerenderMissingIdHandlerValue =| 'fail'| 'warn'| 'ignore'| PrerenderMissingIdHandler;
PrerenderOptionpermalink
ts
type PrerenderOption = boolean | 'auto';
Prerenderedpermalink
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)
RequestOptionspermalink
ts
interface RequestOptions {…}
ts
getClientAddress(): string;
ts
platform?: App.Platform;
RouteSegmentpermalink
ts
interface RouteSegment {…}
ts
content: string;
ts
dynamic: boolean;
ts
rest: boolean;
TrailingSlashpermalink
ts
type TrailingSlash = 'never' | 'always' | 'ignore';
Generated typespermalink
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
:
ts
/** @type {import('@sveltejs/kit').RequestHandler<{foo: string;bar: string;baz: string}>} */export async functionA function whose declared type is neither 'void' nor 'any' must return a value.2355A function whose declared type is neither 'void' nor 'any' must return a value.({ GET params }) {// ...}
ts
export constType '({ 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'.: import('@sveltejs/kit'). GET RequestHandler <{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 :
ts
import type * asKit from '@sveltejs/kit';typeRouteParams = {foo : string;bar : string;baz : string;}export typePageServerLoad =Kit .ServerLoad <RouteParams >;export typePageLoad =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 :
ts
/** @type {import('./$types').PageServerLoad} */export async functionGET ({params }) {// ...}
ts
import type {PageServerLoad } from './$types';export constGET :PageServerLoad = async ({params }) => {// ...};
ts
/** @type {import('./$types').PageLoad} */export async functionload ({params ,fetch }) {// ...}
ts
import type {PageLoad } from './$types';export constload :PageLoad = async ({params ,fetch }) => {// ...};
Pour que ceci fonctionne, votre propre fichier
tsconfig.json
oujsconfig.json
doit étendre le fichier.svelte-kit/tsconfig.json
que SvelteKit génère (où.svelte-kit
est votreoutDir
) :
{ "extends": "./.svelte-kit/tsconfig.json" }
tsconfig.json par défautpermalink
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 :
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 :
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"}}
Apppermalink
Errorpermalink
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;
Localspermalink
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 {}
PageDatapermalink
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 {}
PageStatepermalink
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 {}
Platformpermalink
Si votre adaptateur fournit un contexte spécifique à sa plateforme via event.platform
, vous pouvez le spécifier ici.
ts
interface Platform {}