## Erreurs client [!VO]Client errors ### async_derived_orphan ``` Cannot create a `$derived(...)` with an `await` expression outside of an effect tree ``` Il y a deux types de réactions dans Svelte — les [`$derived`](/docs/svelte/$derived) et les [`$effect`](/docs/svelte/$effect). Les dérivés peuvent être créés n'importe où, car ils sont exécutés en _différé_ et peuvent être [nettoyés par le ramasse-miettes](https://developer.mozilla.org/fr/docs/Glossary/Garbage_collection) si plus rien ne leur fait référence. Les effets, en revanche, continuent d'être exécutés immédiatement dès qu'une de leurs dépendances change, tant qu'ils n'ont pas été détruits. Pour cette raison, les effets peuvent uniquement être créés au sein d'autres effets (ou d'[effets racine](/docs/svelte/$effect#$effect.root), tels que celui qui est créé lorsque vous montez un composant pour la première fois), afin que Svelte sache quand les détruire. Un tour de passe-passe se produit lorsqu'un dérivé contient une expression `await` : puisqu'attendre jusqu'à ce qu'on lise `{await getPromise()}` pour appeler `getPromise` ferait arriver trop tard, nous utilisons un effet pour plutôt l'appeler proactivement, prévenant Svelte lorsque la valeur est rendue disponible. Mais puisque nous utilisons un effet, nous pouvons uniquement créer des dérivés asynchrones au sein d'un autre effet. ### bind_invalid_checkbox_value ``` Using `bind:value` together with a checkbox input is not allowed. Use `bind:checked` instead ``` ### bind_invalid_export ``` Component %component% has an export named `%key%` that a consumer component is trying to access using `bind:%key%`, which is disallowed. Instead, use `bind:this` (e.g. `<%name% bind:this={component} />`) and then access the property on the bound component instance (e.g. `component.%key%`) ``` ### bind_not_bindable ``` A component is attempting to bind to a non-bindable property `%key%` belonging to %component% (i.e. `<%name% bind:%key%={...}>`). To mark a property as bindable: `let { %key% = $bindable() } = $props()` ``` ### component_api_changed ``` Calling `%method%` on a component instance (of %component%) is no longer valid in Svelte 5 ``` See the [migration guide](/docs/svelte/v5-migration-guide#Components-are-no-longer-classes) for more information. ### component_api_invalid_new ``` Attempted to instantiate %component% with `new %name%`, which is no longer valid in Svelte 5. If this component is not under your control, set the `compatibility.componentApi` compiler option to `4` to keep it working. ``` See the [migration guide](/docs/svelte/v5-migration-guide#Components-are-no-longer-classes) for more information. ### derived_references_self ``` A derived value cannot reference itself recursively ``` ### each_key_duplicate ``` Keyed each block has duplicate key at indexes %a% and %b% ``` ``` Keyed each block has duplicate key `%value%` at indexes %a% and %b% ``` ### each_key_volatile ``` Keyed each block has key that is not idempotent — the key for item at index %index% was `%a%` but is now `%b%`. Keys must be the same each time for a given item ``` L'expression de clé dans un bloc `{#each}` doit renvoyer la même valeur lorsque calculée plusieurs fois pour le même élément. L'utilisation d'expressions comme `[item.a, item.b]` crée un nouveau tableau à chaque fois, qui ne sera donc jamais égal à lui-même. Utilisez plutôt une valeur primitive ou créez une clé stable comme `item.a + '-' + item.b`. ### effect_in_teardown ``` `%rune%` cannot be used inside an effect cleanup function ``` ### effect_in_unowned_derived ``` Effect cannot be created inside a `$derived` value that was not itself created inside an effect ``` ### effect_orphan ``` `%rune%` can only be used inside an effect (e.g. during component initialisation) ``` Les effets peuvent uniquement être créés lorsque un effet parent est en cours. Ceci signifie qu'ils ne peuvent pas, par exemple, être créés au sein d'un gestionnaire d'évènement ou après une expression `await` (à moins que le `await` ne se produise directement au sein de la balise ` ``` ### hydration_failed ``` Failed to hydrate the application ``` ### invalid_snippet ``` Could not `{@render}` snippet due to the expression being `null` or `undefined`. Consider using optional chaining `{@render snippet?.()}` ``` ### lifecycle_legacy_only ``` `%name%(...)` cannot be used in runes mode ``` ### props_invalid_value ``` Cannot do `bind:%key%={undefined}` when `%key%` has a fallback value ``` ### props_rest_readonly ``` Rest element properties of `$props()` such as `%property%` are readonly ``` ### rune_outside_svelte ``` The `%rune%` rune is only available inside `.svelte` and `.svelte.js/ts` files ``` ### state_descriptors_fixed ``` Property descriptors defined on `$state` objects must contain `value` and always be `enumerable`, `configurable` and `writable`. ``` ### state_prototype_fixed ``` Cannot set prototype of `$state` object ``` ### state_unsafe_mutation ``` Updating state inside `$derived(...)`, `$inspect(...)` or a template expression is forbidden. If the value should not be reactive, declare it without `$state` ``` Cette erreur se produit lorsqu'un état est mis à jour pendant l'évaluation d'un `$derived`. Vous pourriez la rencontrer alors que vous essayez de "dériver" deux morceaux d'état en une seule fois : ```svelte
{count} est pair : {even}
{count} est impair : {odd}
``` Ceci est interdit car cela introduit de l'instabilité : si `{count} est pair : {even}
` est mis à jour avant que `odd` ne soit recalculé, `even` sera périmé. Dans la plupart des cas, la solution est de tout dériver : ```js let count = 0; // ---cut--- let even = $derived(count % 2 === 0); let odd = $derived(!even); ``` Si les effets de bord sont inévitable, utilisez plutôt [`$effect`]($effect). ### svelte_boundary_reset_onerror ``` A `{label}
``` ### store_invalid_shape ``` `%name%` is not a store with a `subscribe` method ``` ### svelte_element_invalid_this_value ``` The `this` prop on `