Skip to main content

Référence

Configuration

Éditer cette page sur Github

Votre configuration de projet se trouve dans un fichier svelte.config.js à la racine du projet. Comme SvelteKit, cet objet de configuration est utilisé par d'autres outillages qui s'intègrent avec Svelte tels que les extensions d'éditeurs de texte.

svelte.config.js
ts
import adapter from '@sveltejs/adapter-auto';
/** @type {import('@sveltejs/kit').Config} */
const config = {
kit: {
adapter: adapter()
}
};
export default config;
ts
interface Config {}
ts
compilerOptions?: CompileOptions;
  • par défaut {}

Options passed to svelte.compile.

ts
extensions?: string[];
  • par défaut [".svelte"]

List of file extensions that should be treated as Svelte files.

ts
kit?: KitConfig;

SvelteKit options

ts
preprocess?: any;

Preprocessor options, if any. Preprocessing can alternatively also be done through Vite's preprocessor capabilities.

ts
vitePlugin?: PluginOptions;

vite-plugin-svelte plugin options.

ts
[key: string]: any;

Any additional options required by tooling that integrates with Svelte.

La propriété kit configure SvelteKit, et peut avoir les propriétés suivantes :

adapter

  • par défaut undefined
  • Votre adaptateur est ce qui est exécuté lorsque vous lancez vite build. Il détermine comment votre projet est compilé selon différentes plateformes.

alias

  • par défaut {}

Un objet contenant zéro alias ou plus utilisés pour remplacer des valeurs dans déclarations import. Ces alias sont automatiquement passés à Vite et TypeScript.

svelte.config.js
ts
/** @type {import('@sveltejs/kit').Config} */
const config = {
kit: {
alias: {
// ceci va correspondre à un fichier
'my-file': 'path/to/my-file.js',
// ceci va correspondre à un dossier et son contenu
// (`my-directory/x` va renvoyer vers `path/to/my-directory/x`)
'my-directory': 'path/to/my-directory',
// un alias se terminant par /* va seulement correspondre
// au contenu du dossier, pas au dossier lui-même
'my-directory/*': 'path/to/my-directory/*'
}
}
};

L'alias intégré $lib est contrôlé par config.kit.files.lib puisqu'il est utilisé pour le packaging.

Vous aurez besoin de lancer npm run dev pour laisser SvelteKit générer automatiquement la configuration d'alias définie par jsconfig.json ou tsconfig.json.

appDir

  • par défaut "_app"

Le dossier dans lequel SvelteKit génère les fichiers, y compris les fichiers statiques (dont les fichier Javascript et CSS) ainsi que les routes utilisées en interne.

Si paths.assets est spécifié, il y aura deux dossiers plutôt qu'un — ${paths.assets}/${appDir} et ${paths.base}/${appDir}.

csp

La configuration CSP. Les CSP vous aident à protéger vos utilisateurs et utilisatrices contre les attaques XSS, en limitant les endroits depuis lesquels les ressources peuvent être téléchargées. Par exemple, une configuration comme celle-ci...

svelte.config.js
ts
/** @type {import('@sveltejs/kit').Config} */
const config = {
kit: {
csp: {
directives: {
'script-src': ['self']
},
reportOnly: {
'script-src': ['self']
}
}
}
};
export default config;

... empêche les scripts d'être téléchargés depuis des sites externes. SvelteKit ajoute aux directives spécifiées des nonces ou des hashs (en fonction du mode) pour tout style inliné et script qu'il génère.

Pour ajouter un nonce aux scripts et links inclus manuellement dans le fichier src/app.html, vous pouvez utiliser le placeholder %sveltekit.nonce% (par exemple <script nonce="%sveltekit.nonce%">).

Lorsque les pages sont prérendues, le header CSP est ajouté via une balise <meta http-equiv> (notez que dans ce cas, les directives frame-ancestors, report-uri et sandbox sont ignorées).

Lorsque mode vaut 'auto', SvelteKit utilise des nonces pour les pages dynamiquement rendues et des hashs pour les pages prérendues. Utiliser des nonces avec des pages prérendues n'est pas sécurisé et donc interdit.

Notez que la plupart des transitions Svelte fonctionnent en créant un élément <style> inliné. Si vous les utilisez dans votre application, vous devez soit laisser la directive style-src non spécifiée, soit ajouter unsafe-inline.

Si ce niveau de configuration est insuffisant et vous avez des besoins plus dynamiques, vous pouvez utiliser le hook handle pour définir vous-même vos CSP.

ts
mode?: 'hash' | 'nonce' | 'auto';

Mode indiquant d'utiliser des hashs ou des nonces pour restreindre les éléments <script> et <style>. 'auto' utilisera les hashs pour les pages prérendues, et des nonces pour les pages rendues dynamiquement.

ts
directives?: CspDirectives;

Les directives qui seront ajoutées aux headers Content-Security-Policy.

ts
reportOnly?: CspDirectives;

Les directives qui seront ajoutées aux headers Content-Security-Policy-Report-Only.

csrf

Protection contre les attaques de type CSRF.

ts
checkOrigin?: boolean;
  • par défaut true

Vérifie ou non que le header origin pour les soumissions de formulaire POST, PUT, PATCH ou DELETE correspond à l'origine du serveur.

Si vous souhaitez que des personnes puissent faire des requêtes POST, PUT, PATCH ou DELETE avec un Content-Type valant application/x-www-form-urlencoded, multipart/form-data, ou text/plain vers votre application depuis d'autres origines, vous devrez désactiver cette option. Soyez vigilants !

embedded

  • par défaut false

Si oui ou non l'application est embarquée dans une application plus grande. Si vaut true, SvelteKit ajoute les gestionnaires d'évènements liés à la navigation sur le parent du %sveltekit.body% plutôt que sur window, et passe les params depuis le serveur plutôt que de les inférer depuis location.pathname. Notez que vous ne devriez en général pas embarquer plusieurs applications SvelteKit sur la même page et utiliser les fonctionnalités client (des choses comme la mise à jour de l'historique de navigation supposent qu'il y ait une seule instance par page).

env

Configuration des variables d'environnement

ts
dir?: string;
  • par défaut "."

Le dossier dans lequel se trouve vos fichiers .env.

ts
publicPrefix?: string;
  • par défaut "PUBLIC_"

Un préfixe qui signale qu'une variable d'environnement est exposable en toute sécurité au code client. Voir $env/static/public et $env/dynamic/public. Notez que le préfixe envPrefix de Vite doit être défini à part si vous utilisez le gestionnaire de variables d'environnement de Vite – même si l'usage de cette fonctionnalité n'est en général pas nécessaire.

ts
privatePrefix?: string;
  • par défaut ""

Un préfixe qui signale qu'une variable d'environnement n'est pas exposable en toute sécurité au code client. Les variables d'environnement qui ne correspondent ni au préfixe publique ni au préfixe privé seront complètement ignorées. Voir $env/static/public et $env/dynamic/public.

files

Les emplacements de différents fichiers dans votre projet.

ts
assets?: string;
  • par défaut "static"

un endroit pour placer les fichiers statiques qui doivent avoir des URLS stables et n'être soumis à aucun traitement, comme favicon.ico ou manifest.json

ts
hooks?: {}
ts
client?: string;
  • par défaut "src/hooks.client"

L'emplacement de vos hooks client.

ts
server?: string;
  • par défaut "src/hooks.server"

L'emplacement de vos hooks serveur.

ts
universal?: string;
  • par défaut "src/hooks"

The location of your universal hooks.

ts
lib?: string;
  • par défaut "src/lib"

la librairie interne de votre application, accessible dans votre code via $lib

ts
params?: string;
  • par défaut "src/params"

un dossier contenant vos fonctions match

ts
routes?: string;
  • par défaut "src/routes"

les fichiers qui définissent la structure de votre application (voir Routing)

ts
serviceWorker?: string;
  • par défaut "src/service-worker"

l'emplacement du point d'entrée de vos service workers (voir Service workers)

ts
appTemplate?: string;
  • par défaut "src/app.html"

l'emplacement du template pour les réponses HTML

ts
errorTemplate?: string;
  • par défaut "src/error.html"

l'emplacement du template pour les réponses d'erreur de secours

inlineStyleThreshold

  • par défaut 0

Inline le CSS dans un bloc <style> en haut du HTML. Cette option est un nombre qui précise la longueur maximale d'un fichier CSS inliné en unités de code UTF-16, comme spécifié par la propriété String.length. Tous les fichiers CSS requis pour la page plus petits que cette valeur sont fusionnés et inlinés dans un seul bloc <style>.

Ceci permet de réduire le nombre initial de requêtes et peut améliorer votre score First Contentful Paint. Cependant, cela génère des fichiers HTML plus lourds et réduit l'efficacité des caches de navigateur. Servez-vous en avec précaution.

moduleExtensions

  • par défaut [".js", ".ts"]

Un tableau d'extensions de fichiers que SvelteKit va traiter comme des modules. Les fichiers avec des extensions qui ne correspondent ni à config.extensions ni à config.kit.moduleExtensions seront ignorés par le routeur.

outDir

  • par défaut ".svelte-kit"

Le dossier dans lequel SvelteKit écrit les fichiers lors de dev et build. Vous devriez exclure ce dossier de votre contrôle de version.

output

Des options liées au format du dossier de compilation cible

ts
preloadStrategy?: 'modulepreload' | 'preload-js' | 'preload-mjs';
  • par défaut "modulepreload"

SvelteKit va précharger les modules JavaScript nécessaires pour la page initiale pour éviter des "cascades", impliquant un démarrage plus rapide de l'application. Il y a trois stratégies avec différents compromis :

  • modulepreload - utilise <link rel="modulepreload">. Cette option fournit les meilleurs résultats dans les navigateurs basés sur Chromium, dans Firefox 115+, et Safari 17+. Elle est ignorée dans les navigateurs plus anciens.
  • preload-js - utilise <link rel="preload">. Évite les cascades dans Chromium et Safari, mais Chromium va traiter chaque module deux fois (une fois en tant que script, une fois en tant que module). Implique que les modules sont requêtés deux fois dans Firefox. C'est une bonne option si vous souhaitez maximiser la performance sur les appareils iOS au prix d'une très légère dégradation sur Chromium.
  • preload-mjs - utilise <link rel="preload"> mais avec l'extension .mjs qui empêche le double traitement par Chromium. Certains serveurs web statiques échoueront à servir les fichiers .mjs avec un header Content-Type: application/javascript, ce qui fera planter votre application. Si ceci ne s'applique pas pour vous, cette option fournira la meilleure performance pour le plus grand nombre de personnes, jusqu'à ce que modulepreload soit plus largement supporté.

paths

ts
assets?: '' | `http://${string}` | `https://${string}`;
  • par défaut ""

Un chemin absolu depuis lequel les fichiers statiques de votre application sont servis. Ceci est utile si vos fichiers sont servis depuis un espace de stockage.

ts
base?: '' | `/${string}`;
  • par défaut ""

Un chemin relatif à la racine qui doit commencer, mais pas se terminer par / (par ex. /base-path), à moins que ce ne soit la chaîne de caractères vide. Ceci précise d'où votre application est servie et lui permet d'exister sur un chemin non racine. Notez que vous aurez besoin de préfixer tous vos liens relatifs à la racine avec la valeur de base, au risque de les faire pointer vers la racine de votre domaine, et non vers votre base (les navigateurs fonctionnent ainsi). Vous pouvez utiliser base importée depuis $app/paths pour faire cela: <a href="{base}/votre-page">Lien</a>. Si vous devez faire souvent ce remplacement, il peut être utile d'extraire cette logique dans un composant réutilisable.

ts
relative?: boolean;
  • par défaut true

Si oui ou non utiliser des chemins de fichiers statiques relatifs.

Si true, base et assets importées depuis $app/paths seront remplacées avec des chemins de fichiers statiques relatifs lors du rendu côté serveur, impliquant du HTML portable. Si false, %sveltekit.assets% et les références vers les artefacts de compilation seront toujours des chemins relatifs à la racine, à moins que paths.assets soit une URL externe.

Les pages de fallback des SPA utilisera toujours des chemins absolus, quelque soit la valeur de cette configuration.

Si votre application utilise un élément <base>, vous devriez définir cette option à false, sinon les URLs de fichiers statiques seront résolues par rapport à <base> plutôt que par rapport à la page courante.

Avec SvelteKit 1.0, undefined était une valeur valide, qui était celle par défaut. Dans ce cas, si paths.assets n'était pas externe, SvelteKit remplaçait %sveltekit.assets% avec un chemin relatif et utilisait des chemins relatifs pour référencer les artéfacts générés ; mais base et assets importés depuis $app/paths étaient résolues comme définis dans votre configuration.

prerender

Voir la section Prerendering.

ts
concurrency?: number;
  • par défaut 1

Nombre de pages pouvant être prérendues simultanément. JS ne s'exécute que sur un seul thread, mais dans les cas où la performance de prérendu est liée au réseau (par exemple en chargeant du contenu depuis un CMS distant) ceci peut accélérer le processus en effectuant d'autres tâches pendant que les requêtes se terminent.

ts
crawl?: boolean;
  • par défaut true

Si oui ou non SvelteKit devrait trouver des pages à prérendre en suivant des liens depuis les entrées entries.

ts
entries?: Array<'*' | `/${string}`>;
  • par défaut ["*"]

Un tableau de pages à prérendre, ou depuis lequel commencer à chercher des liens (si crawl: true). La chaîne de caractères * permet d'inclure toutes les routes non dynamiques (c'est-à-dire les pages sans [parametres] ou vide, car SvelteKit ne sait pas d'avance les valeurs que vos paramètres peuvent avoir).

ts
handleHttpError?: PrerenderHttpErrorHandlerValue;
  • par défaut "fail"

Comportement de SvelteKit lors d'erreurs HTTP rencontrées pendant le prérendu de l'application.

  • 'fail' — fait échouer la compilation
  • 'ignore' - ignore l'erreur en silence et continue
  • 'warn' — continue, mais affiche un avertissement
  • (details) => void — un gestionnaire d'erreur personnalisé qui prend en entrée un objet details possédant les propriétés status, path, referrer, referenceType et message. Si vous utilisez throw depuis cette fonction, la compilation échouera
svelte.config.js
ts
/** @type {import('@sveltejs/kit').Config} */
const config = {
kit: {
prerender: {
handleHttpError: ({ path, referrer, message }) => {
// ignore délibérément le lien vers une page 404
if (path === '/not-found' && referrer === '/blog/how-we-built-our-404-page') {
return;
}
// sinon fait échouer la compilation
throw new Error(message);
}
}
}
};
ts
handleMissingId?: PrerenderMissingIdHandlerValue;
  • par défaut "fail"

Comportement de SvelteKit lorsque les liens d'une page prérendue vers une autre ne correspondent pas à l'id de la page cible.

  • 'fail' — fait échouer la compilation
  • 'ignore' - ignore l'erreur en silence et continue
  • 'warn' — continue, mais affiche un avertissement
  • (details) => void — un gestionnaire d'erreur personnalisé qui prend en entrée un objet details possédant les propriétés path, id, referrers et message. Si vous utilisez throw depuis cette fonction, la compilation échouera
ts
handleEntryGeneratorMismatch?: PrerenderEntryGeneratorMismatchHandlerValue;
  • par défaut "fail"

Comportement de SvelteKit lorsqu'une entrée générée par l'export entries ne correspond pas à la route depuis laquelle elle a été générée.

  • 'fail' — fait échouer la compilation
  • 'ignore' - ignore l'erreur en silence et continue
  • 'warn' — continue, mais affiche un avertissement
  • (details) => void — un gestionnaire d'erreur personnalisé qui prend en entrée un objet details possédant les propriétés generatedFromId, entry, matchedId et message. Si vous utilisez throw depuis cette fonction, la compilation échouera
ts
origin?: string;
  • par défaut "http://sveltekit-prerender"

La valeur de url.origin pendant le prérendu ; utile si l'origine est incluse dans le contenu généré.

serviceWorker

ts
register?: boolean;
  • par défaut true

Si oui ou non utiliser automatiquement le service worker, s'il existe.

ts
files?(filepath: string): boolean;
  • par défaut (filename) => !/\.DS_Store/.test(filename)

Détermine quels fichiers de votre dossier static seront disponibles dans $service-worker.files.

typescript

ts
config?: (config: Record<string, any>) => Record<string, any> | void;
  • par défaut (config) => config

Une fonction qui permet d'éditer le fichier tsconfig.json généré. Vous pouvez muter la configuration (recommandé) ou en renvoyer une nouvelle. Ceci est utile pour étender un fichier tsconfig.json partagé à la racine d'un monorepo, par exemple.

version

Les navigations côté client peuvent être impactées si vous déployez une nouvelle version de votre application pendant que des gens sont en train de l'utiliser. Si le code de la nouvelle page est déjà chargé, il se peut qu'il ait du contenu périmé ; s'il n'est pas encore chargé, le manifeste de routes de votre application peut pointer vers un fichier JavaScript qui n'existe plus. SvelteKit vous aide à résoudre ce problème via une gestion de version. Si Sveltekit rencontre une erreur pendant le chargement de la page et détecte qu'une nouvelle version est déployée (en utilisant le name spécifié ici, qui par défaut a pour valeur le timestamp de compilation), il choisit de passer par une navigation traditionnelle qui recharge entièrement la page. Mais toutes les navigations ne débouchent pas toujours sur une erreur, par exemple si le code JavaScript de la nouvelle page est déjà chargé. Si vous souhaitez toujours forcer une navigation qui recharge toute la page dans ces cas-là, vous pouvez utiliser des techniques telles que définir l'option pollInterval puis utiliser beforeNavigate :

+layout.svelte
<script>
	import { beforeNavigate } from '$app/navigation';
	import { updated } from '$app/stores';

	beforeNavigate(({ willUnload, to }) => {
		if ($updated && !willUnload && to?.url) {
			location.href = to.url.href;
		}
	});
</script>

Si vous définissez pollInterval comme étant une valeur différente de zéro, SvelteKit va régulièrement vérifier en tâche de fond si une nouvelle version de votre application existe, et mettre la valeur du store updated à true s'il détecte une nouvelle version.

ts
name?: string;

La version actuelle de votre application. Si précisée, cette valeur doit être déterministe (c'est-à-dire une référence de commit plutôt qu'un Math.random() ou Date.now().toString()). Si non précisée, cette valeur vaut le timestamp de la dernière compilation.

Par exemple, pour utiliser le hash du dernier commit, vous pouvez utiliser git rev-parse HEAD :

svelte.config.js
ts
import * as child_process from 'node:child_process';
export default {
kit: {
version: {
name: child_process.execSync('git rev-parse HEAD').toString().trim()
}
}
};
ts
pollInterval?: number;
  • par défaut 0

Un intervalle en millisecondes pour vérifier l'existence de nouvelles version. Si cette valeur vaut 0, aucune vérification n'est faite.

précédent Référencement
suivant CLI