Foire À Questions

import pkgimport pkg from './package.json' with { typeany: 'json' };

import { onNavigate(alias) function onNavigate(callback: (navigation: OnNavigate) => MaybePromise<void | (() => void)>): void
import onNavigate
A lifecycle function that runs the supplied callback immediately before we navigate to a new URL except during full-page navigations.
If you return a Promise, SvelteKit will wait for it to resolve before completing the navigation. This allows you to — for example — use document.startViewTransition. Avoid promises that are slow to resolve, since navigation will appear stalled to the user.
If a function (or a Promise that resolves to a function) is returned from the callback, it will be called once the DOM has updated.
onNavigate must be called during a component initialization. It remains active as long as the component is mounted.
reference } from '$app/navigation';

onNavigate(alias) onNavigate(callback: (navigation: OnNavigate) => MaybePromise<void | (() => void)>): void
import onNavigate
A lifecycle function that runs the supplied callback immediately before we navigate to a new URL except during full-page navigations.
If you return a Promise, SvelteKit will wait for it to resolve before completing the navigation. This allows you to — for example — use document.startViewTransition. Avoid promises that are slow to resolve, since navigation will appear stalled to the user.
If a function (or a Promise that resolves to a function) is returned from the callback, it will be called once the DOM has updated.
onNavigate must be called during a component initialization. It remains active as long as the component is mounted.
reference((navigation(parameter) navigation: (NavigationGoto & {
    type: Exclude<NavigationType, "enter" | "leave">;
    willUnload: false;
}) | (NavigationFormSubmit & {
    type: Exclude<NavigationType, "enter" | "leave">;
    willUnload: false;
}) | (NavigationPopState & {
    type: Exclude<NavigationType, "enter" | "leave">;
    willUnload: false;
}) | (NavigationLink & {
    type: Exclude<NavigationType, "enter" | "leave">;
    willUnload: false;
})) => {
	if (!documentvar document: Document
window.document returns a reference to the document contained in the window.
MDN Reference
.startViewTransition(method) Document.startViewTransition(callbackOptions?: ViewTransitionUpdateCallback | StartViewTransitionOptions): ViewTransition
The startViewTransition() method of the Document interface starts a new same-document (SPA) view transition and returns a ViewTransition object to represent it.
MDN Reference
) return;

	return new Promisevar Promise: PromiseConstructor
new <void | (() => void)>(executor: (resolve: (value: void | (() => void) | PromiseLike<void | (() => void)>) => void, reject: (reason?: any) => void) => void) => Promise<void | (() => void)>
Creates a new Promise.
executor 
A callback used to initialize the promise. This callback is passed two arguments:
a resolve callback used to resolve the promise with a value or the result of another promise,
and a reject callback used to reject the promise with a provided reason or error.
((resolve(parameter) resolve: (value: void | (() => void) | PromiseLike<void | (() => void)>) => void) => {
		documentvar document: Document
window.document returns a reference to the document contained in the window.
MDN Reference
.startViewTransition(method) Document.startViewTransition(callbackOptions?: ViewTransitionUpdateCallback | StartViewTransitionOptions): ViewTransition
The startViewTransition() method of the Document interface starts a new same-document (SPA) view transition and returns a ViewTransition object to represent it.
MDN Reference
(async () => {
			resolve(parameter) resolve: (value: void | (() => void) | PromiseLike<void | (() => void)>) => void();
			await navigation(parameter) navigation: (NavigationGoto & {
    type: Exclude<NavigationType, "enter" | "leave">;
    willUnload: false;
}) | (NavigationFormSubmit & {
    type: Exclude<NavigationType, "enter" | "leave">;
    willUnload: false;
}) | (NavigationPopState & {
    type: Exclude<NavigationType, "enter" | "leave">;
    willUnload: false;
}) | (NavigationLink & {
    type: Exclude<NavigationType, "enter" | "leave">;
    willUnload: false;
}).complete(property) NavigationBase.complete: Promise<void>
A promise that resolves once the navigation is complete, and rejects if the navigation
fails or is aborted. In the case of a willUnload navigation, the promise will never resolve
;
		});
	});
});

import { browser(alias) const browser: boolean
import browser
true if the app is running in the browser.
reference } from '$app/environment';

if (browser(alias) const browser: boolean
import browser
true if the app is running in the browser.
reference) {
	// votre code uniquement client se place ici
}

import { onMount(alias) function onMount<T>(fn: () => NotFunction<T> | Promise<NotFunction<T>> | (() => any)): void
import onMount
onMount, like $effect, schedules a function to run as soon as the component has been mounted to the DOM.
Unlike $effect, the provided function only runs once.
It must be called during the component's initialisation (but doesn't need to live inside the component;
it can be called from an external module). If a function is returned synchronously from onMount,
it will be called when the component is unmounted.
onMount functions do not run during server-side rendering.
reference } from 'svelte';

onMount(alias) onMount<void>(fn: () => void | (() => any) | Promise<void>): void
import onMount
onMount, like $effect, schedules a function to run as soon as the component has been mounted to the DOM.
Unlike $effect, the provided function only runs once.
It must be called during the component's initialisation (but doesn't need to live inside the component;
it can be called from an external module). If a function is returned synchronously from onMount,
it will be called when the component is unmounted.
onMount functions do not run during server-side rendering.
reference(async () => {
	const { methodconst method: any } = await import('some-browser-only-library');
	methodconst method: any('bonjour tout le monde');
});

import { onMount(alias) function onMount<T>(fn: () => NotFunction<T> | Promise<NotFunction<T>> | (() => any)): void
import onMount
onMount, like $effect, schedules a function to run as soon as the component has been mounted to the DOM.
Unlike $effect, the provided function only runs once.
It must be called during the component's initialisation (but doesn't need to live inside the component;
it can be called from an external module). If a function is returned synchronously from onMount,
it will be called when the component is unmounted.
onMount functions do not run during server-side rendering.
reference } from 'svelte';
import { method(alias) module "some-browser-only-library"
import method } from 'some-browser-only-library';

onMount(alias) onMount<void>(fn: () => void | (() => any) | Promise<void>): void
import onMount
onMount, like $effect, schedules a function to run as soon as the component has been mounted to the DOM.
Unlike $effect, the provided function only runs once.
It must be called during the component's initialisation (but doesn't need to live inside the component;
it can be called from an external module). If a function is returned synchronously from onMount,
it will be called when the component is unmounted.
onMount functions do not run during server-side rendering.
reference(() => {
	method(alias) module "some-browser-only-library"
import method('bonjour tout le monde');
});

<script>
	import { browser } from '$app/environment';

	const promise = browser
		? import('./BrowserComponent.svelte')
		: import('./ServerComponent.svelte');
</script>

{#await promise}
	<p>Chargement...</p>
{:then module}
	<module.default />
{:catch error}
	<p>Quelque chose s'est mal passé : {error.message}</p>
{/await}

<script lang="ts">
	import { browser } from '$app/environment';

	const promise = browser
		? import('./BrowserComponent.svelte')
		: import('./ServerComponent.svelte');
</script>

{#await promise}
	<p>Chargement...</p>
{:then module}
	<module.default />
{:catch error}
	<p>Quelque chose s'est mal passé : {error.message}</p>
{/await}

/** @type {import('./$types').RequestHandler} */
export function GETfunction GET(event: RequestEvent<Record<string, any>, string | null>): MaybePromise<Response>
{import('./$types').RequestHandler}
({ params(parameter) params: Record<string, any>
The parameters of the current route - e.g. for a route like /blog/[slug], a { slug: string } object.
In the context of a remote function request initiated by the client, this relates to the page the remote function
was called from, not the URL of the endpoint SvelteKit creates for the remote function. Never use this to determine
whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
, url(parameter) url: URL
The requested URL.
In the context of a remote function request initiated by the client, this relates to the page the remote function
was called from, not the URL of the endpoint SvelteKit creates for the remote function. Never use this to determine
whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
 }) {
	return fetchfunction fetch(input: string | URL | Request, init?: RequestInit): Promise<Response> (+1 overload)
MDN Reference
(`https://example.com/${params(parameter) params: Record<string, any>
The parameters of the current route - e.g. for a route like /blog/[slug], a { slug: string } object.
In the context of a remote function request initiated by the client, this relates to the page the remote function
was called from, not the URL of the endpoint SvelteKit creates for the remote function. Never use this to determine
whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
.pathany + url(parameter) url: URL
The requested URL.
In the context of a remote function request initiated by the client, this relates to the page the remote function
was called from, not the URL of the endpoint SvelteKit creates for the remote function. Never use this to determine
whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
.search(property) URL.search: string
The search property of the URL interface is a search string, also called a query string, that is a string containing a "?" followed by the parameters of the URL. If the URL does not have a search query, this property contains an empty string, "".
MDN Reference
}`);
}

import type { RequestHandler(alias) type RequestHandler = (event: RequestEvent<Record<string, any>, string | null>) => MaybePromise<Response>
import RequestHandler } from './$types';

export const GETconst GET: RequestHandler: RequestHandler(alias) type RequestHandler = (event: RequestEvent<Record<string, any>, string | null>) => MaybePromise<Response>
import RequestHandler = ({ params(parameter) params: Record<string, any>
The parameters of the current route - e.g. for a route like /blog/[slug], a { slug: string } object.
In the context of a remote function request initiated by the client, this relates to the page the remote function
was called from, not the URL of the endpoint SvelteKit creates for the remote function. Never use this to determine
whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
, url(parameter) url: URL
The requested URL.
In the context of a remote function request initiated by the client, this relates to the page the remote function
was called from, not the URL of the endpoint SvelteKit creates for the remote function. Never use this to determine
whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
 }) => {
	return fetchfunction fetch(input: string | URL | Request, init?: RequestInit): Promise<Response> (+1 overload)
MDN Reference
(`https://example.com/${params(parameter) params: Record<string, any>
The parameters of the current route - e.g. for a route like /blog/[slug], a { slug: string } object.
In the context of a remote function request initiated by the client, this relates to the page the remote function
was called from, not the URL of the endpoint SvelteKit creates for the remote function. Never use this to determine
whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
.pathany + url(parameter) url: URL
The requested URL.
In the context of a remote function request initiated by the client, this relates to the page the remote function
was called from, not the URL of the endpoint SvelteKit creates for the remote function. Never use this to determine
whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
.search(property) URL.search: string
The search property of the URL interface is a search string, also called a query string, that is a string containing a "?" followed by the parameters of the URL. If the URL does not have a search query, this property contains an empty string, "".
MDN Reference
}`);
};

import { sveltekit(alias) function sveltekit(config?: KitConfig & Omit<Options, "onwarn"> & Pick<SvelteConfig, "vitePlugin">): Promise<Plugin[]>
import sveltekit
Returns the SvelteKit Vite plugins.
Since version 2.62.0 you can pass configuration directly, in which case svelte.config.js is ignored.
Any options that don't belong to SvelteKit are passed through to vite-plugin-svelte.
reference } from '@sveltejs/kit/vite';

/** @type {import('vite').Plugin} */
const myPluginconst myPlugin: Plugin<any>
{import('vite').Plugin}
 = {
	name(property) OutputPlugin.name: string
The name of the plugin, for use in error messages and logs.
: 'log-request-middleware',
	configureServer(property) Plugin<any>.configureServer?: ObjectHook<ServerHook> | undefined
Configure the vite server. The hook receives the 
{@link 
ViteDevServer
}
instance. This can also be used to store a reference to the server
for use in other hooks.
The hooks will be called before internal middlewares are applied. A hook
can return a post hook that will be called after internal middlewares
are applied. Hook can be async functions and will be called in series.
(server(parameter) server: ViteDevServer) {
		server(parameter) server: ViteDevServer.middlewares(property) ViteDevServer.middlewares: Connect.Server
A connect app instance.

Can be used to attach custom middlewares to the dev server.
Can also be used as the handler function of a custom http server
or as a middleware in any connect-style Node.js frameworks

https://github.com/senchalabs/connect#use-middleware
.use(method) Connect.Server.use(fn: Connect.NextHandleFunction): Connect.Server (+3 overloads)
Utilize the given middleware handle to the given route,
defaulting to /. This "route" is the mount-point for the
middleware, when given a value other than / the middleware
is only effective when that segment is present in the request's
pathname.
For example if we were to mount a function at /admin, it would
be invoked on /admin, and /admin/settings, however it would
not be invoked for /, or /posts.
((req(parameter) req: Connect.IncomingMessage, res(parameter) res: ServerResponse<IncomingMessage>, next(parameter) next: Connect.NextFunction) => {
			consolenamespace console
var console: Console
The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
source
.log(method) Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
See util.format() for more information.
v0.1.100
(`Requête reçue sur ${req(parameter) req: Connect.IncomingMessage.url(property) IncomingMessage.url?: string | undefined
Only valid for request obtained from 
{@link 
Server
}
.
Request URL string. This contains only the URL that is present in the actual
HTTP request. Take the following request:
GET /status?name=ryan HTTP/1.1
Accept: text/plain
To parse the URL into its parts:
new URL(`http://${process.env.HOST ?? 'localhost'}${request.url}`);
When request.url is '/status?name=ryan' and process.env.HOST is undefined:
$ node
> new URL(`http://${process.env.HOST ?? 'localhost'}${request.url}`);
URL {
  href: 'http://localhost/status?name=ryan',
  origin: 'http://localhost',
  protocol: 'http:',
  username: '',
  password: '',
  host: 'localhost',
  hostname: 'localhost',
  port: '',
  pathname: '/status',
  search: '?name=ryan',
  searchParams: URLSearchParams { 'name' => 'ryan' },
  hash: ''
}
Ensure that you set process.env.HOST to the server's host name, or consider replacing this part entirely. If using req.headers.host, ensure proper
validation is used, as clients may specify a custom Host header.
v0.1.90
}`);
			next(parameter) next: (err?: any) => void();
		});
	}
};

/** @type {import('vite').UserConfig} */
const configconst config: UserConfig
{import('vite').UserConfig}
 = {
	plugins(property) UserConfig.plugins?: PluginOption[] | undefined
Array of vite plugins to use.
: [myPluginconst myPlugin: Plugin<any>
{import('vite').Plugin}
, sveltekit(alias) sveltekit(config?: KitConfig & Omit<Options, "onwarn"> & Pick<SvelteConfig, "vitePlugin">): Promise<Plugin[]>
import sveltekit
Returns the SvelteKit Vite plugins.
Since version 2.62.0 you can pass configuration directly, in which case svelte.config.js is ignored.
Any options that don't belong to SvelteKit are passed through to vite-plugin-svelte.
reference()]
};

export default configconst config: UserConfig
{import('vite').UserConfig}
;

import { sveltekit(alias) function sveltekit(config?: KitConfig & Omit<Options, "onwarn"> & Pick<SvelteConfig, "vitePlugin">): Promise<Plugin[]>
import sveltekit
Returns the SvelteKit Vite plugins.
Since version 2.62.0 you can pass configuration directly, in which case svelte.config.js is ignored.
Any options that don't belong to SvelteKit are passed through to vite-plugin-svelte.
reference } from '@sveltejs/kit/vite';
import type { Plugin(alias) interface Plugin<A = any>
import Plugin
There are two types of plugins in Vite. App plugins and environment plugins.
Environment Plugins are defined by a constructor function that will be called
once per each environment allowing users to have completely different plugins
for each of them. The constructor gets the resolved environment after the server
and builder has already been created simplifying config access and cache
management for environment specific plugins.
Environment Plugins are closer to regular rollup plugins. They can't define
app level hooks (like config, configResolved, configureServer, etc).
, UserConfig(alias) interface UserConfig
import UserConfig } from 'vite';

const myPluginconst myPlugin: Plugin<any>: Plugin(alias) interface Plugin<A = any>
import Plugin
There are two types of plugins in Vite. App plugins and environment plugins.
Environment Plugins are defined by a constructor function that will be called
once per each environment allowing users to have completely different plugins
for each of them. The constructor gets the resolved environment after the server
and builder has already been created simplifying config access and cache
management for environment specific plugins.
Environment Plugins are closer to regular rollup plugins. They can't define
app level hooks (like config, configResolved, configureServer, etc).
 = {
	name(property) OutputPlugin.name: string
The name of the plugin, for use in error messages and logs.
: 'log-request-middleware',
	configureServer(property) Plugin<any>.configureServer?: ObjectHook<ServerHook> | undefined
Configure the vite server. The hook receives the 
{@link 
ViteDevServer
}
instance. This can also be used to store a reference to the server
for use in other hooks.
The hooks will be called before internal middlewares are applied. A hook
can return a post hook that will be called after internal middlewares
are applied. Hook can be async functions and will be called in series.
(server(parameter) server: ViteDevServer) {
		server(parameter) server: ViteDevServer.middlewares(property) ViteDevServer.middlewares: Connect.Server
A connect app instance.

Can be used to attach custom middlewares to the dev server.
Can also be used as the handler function of a custom http server
or as a middleware in any connect-style Node.js frameworks

https://github.com/senchalabs/connect#use-middleware
.use(method) Connect.Server.use(fn: Connect.NextHandleFunction): Connect.Server (+3 overloads)
Utilize the given middleware handle to the given route,
defaulting to /. This "route" is the mount-point for the
middleware, when given a value other than / the middleware
is only effective when that segment is present in the request's
pathname.
For example if we were to mount a function at /admin, it would
be invoked on /admin, and /admin/settings, however it would
not be invoked for /, or /posts.
((req(parameter) req: Connect.IncomingMessage, res(parameter) res: ServerResponse<IncomingMessage>, next(parameter) next: Connect.NextFunction) => {
			consolenamespace console
var console: Console
The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
source
.log(method) Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
See util.format() for more information.
v0.1.100
(`Requête reçue sur ${req(parameter) req: Connect.IncomingMessage.url(property) IncomingMessage.url?: string | undefined
Only valid for request obtained from 
{@link 
Server
}
.
Request URL string. This contains only the URL that is present in the actual
HTTP request. Take the following request:
GET /status?name=ryan HTTP/1.1
Accept: text/plain
To parse the URL into its parts:
new URL(`http://${process.env.HOST ?? 'localhost'}${request.url}`);
When request.url is '/status?name=ryan' and process.env.HOST is undefined:
$ node
> new URL(`http://${process.env.HOST ?? 'localhost'}${request.url}`);
URL {
  href: 'http://localhost/status?name=ryan',
  origin: 'http://localhost',
  protocol: 'http:',
  username: '',
  password: '',
  host: 'localhost',
  hostname: 'localhost',
  port: '',
  pathname: '/status',
  search: '?name=ryan',
  searchParams: URLSearchParams { 'name' => 'ryan' },
  hash: ''
}
Ensure that you set process.env.HOST to the server's host name, or consider replacing this part entirely. If using req.headers.host, ensure proper
validation is used, as clients may specify a custom Host header.
v0.1.90
}`);
			next(parameter) next: (err?: any) => void();
		});
	}
};

const configconst config: UserConfig: UserConfig(alias) interface UserConfig
import UserConfig = {
	plugins(property) UserConfig.plugins?: PluginOption[] | undefined
Array of vite plugins to use.
: [myPluginconst myPlugin: Plugin<any>, sveltekit(alias) sveltekit(config?: KitConfig & Omit<Options, "onwarn"> & Pick<SvelteConfig, "vitePlugin">): Promise<Plugin[]>
import sveltekit
Returns the SvelteKit Vite plugins.
Since version 2.62.0 you can pass configuration directly, in which case svelte.config.js is ignored.
Any options that don't belong to SvelteKit are passed through to vite-plugin-svelte.
reference()]
};

export default configconst config: UserConfig;

yarn create svelte myapp
cd myapp

yarn set version berry
yarn install

nodeLinker: node-modules