From eb3d491eca8bc6330a036ce175be6c30db8ede1c Mon Sep 17 00:00:00 2001
From: Paolo Dadda <ilpaolino@gmail.com>
Date: Sun, 27 Aug 2023 22:46:36 +0200
Subject: [PATCH 1/5] docs: initial composition-api-setup translation

---
 src/api/composition-api-setup.md | 66 ++++++++++++++++----------------
 1 file changed, 33 insertions(+), 33 deletions(-)

diff --git a/src/api/composition-api-setup.md b/src/api/composition-api-setup.md
index 44f6b8d2..353db22e 100644
--- a/src/api/composition-api-setup.md
+++ b/src/api/composition-api-setup.md
@@ -2,16 +2,16 @@
 
 ## Utilizzo Base {#basic-usage}
 
-The `setup()` hook serves as the entry point for Composition API usage in components in the following cases:
+L'hook `setup()` funge da punto di ingresso per l'uso della Composition API nei componenti nei seguenti casi:
 
-1. Using Composition API without a build step;
-2. Integrating with Composition-API-based code in an Options API component.
+1. Uso della Composition API senza una fase di compilazione;
+2. Integrazione con codice basato su Composition API in un componente con Options API.
 
 :::info Note
-If you are using Composition API with Single-File Components, [`<script setup>`](/api/sfc-script-setup) is strongly recommended for a more succinct and ergonomic syntax.
+Se stai utilizzando la Composition API con i Componenti in un Singolo File, è vivamente consigliato utilizzare [`<script setup>`](/api/sfc-script-setup) per una sintassi più concisa ed ergonomica.
 :::
 
-We can declare reactive state using [Reactivity APIs](./reactivity-core) and expose them to the template by returning an object from `setup()`. The properties on the returned object will also be made available on the component instance (if other options are used):
+Possiamo dichiarare uno stato reattivo utilizzando le [API di reattività](./reactivity-core) ed esporlo al template restituendo un oggetto da `setup()`. Le proprietà dell'oggetto restituito saranno anche accessibili nell'istanza del componente (se vengono utilizzate altre opzioni):
 
 ```vue
 <script>
@@ -21,7 +21,7 @@ export default {
   setup() {
     const count = ref(0)
 
-    // expose to template and other options API hooks
+    // esponi al template e ad altri hook dell'Options API
     return {
       count
     }
@@ -38,15 +38,15 @@ export default {
 </template>
 ```
 
-[refs](/api/reactivity-core#ref) returned from `setup` are [automatically shallow unwrapped](/guide/essentials/reactivity-fundamentals#deep-reactivity) when accessed in the template so you do not need to use `.value` when accessing them. They are also unwrapped in the same way when accessed on `this`.
+I ([refs](/api/reactivity-core#ref)) restituiti da `setup` vengono [automaticamente scartati a basso livello](/guide/essentials/reactivity-fundamentals#deep-reactivity) quando vengono caricati nel template, quindi non è necessario utilizzare `.value` quando li si accede. Vengono scartati nello stesso modo quando vengono acceduti tramite `this`.
 
-`setup()` itself does not have access to the component instance - `this` will have a value of `undefined` inside `setup()`. You can access Composition-API-exposed values from Options API, but not the other way around.
+`setup()` stesso non ha accesso all'istanza del componente - `this` avrà un valore `undefined` all'interno del `setup()`. Dalla Composition API puoi accedere ai valori esposti dall'Options API, ma non viceversa.
 
-`setup()` should return an object _synchronously_. The only case when `async setup()` can be used is when the component is a descendant of a [Suspense](../guide/built-ins/suspense) component.
+`setup()` dovrebbe restituire un oggetto in modo _sincrono_. L'unico caso in cui può essere utilizzato `async setup()` è quando il componente è discendente di un componente [Suspense](../guide/built-ins/suspense).
 
-## Accessing Props {#accessing-props}
+## Accesso alle Props {#accessing-props}
 
-The first argument in the `setup` function is the `props` argument. Just as you would expect in a standard component, `props` inside of a `setup` function are reactive and will be updated when new props are passed in.
+Il primo argomento nella funzione `setup` è l'argomento `props`. Proprio come ci si aspetterebbe in un componente standard, le `props` all'interno di una funzione `setup` sono reattive e si aggiorneranno quando vengono passate nuove props.
 
 ```js
 export default {
@@ -59,21 +59,21 @@ export default {
 }
 ```
 
-Note that if you destructure the `props` object, the destructured variables will lose reactivity. It is therefore recommended to always access props in the form of `props.xxx`.
+Tieni presente che se destrutti l'oggetto `props`, le variabili destrutturate perderanno la reattività. È quindi consigliato accedere sempre alle props nella forma `props.xxx`.
 
-If you really need to destructure the props, or need to pass a prop into an external function while retaining reactivity, you can do so with the [toRefs()](./reactivity-utilities#torefs) and [toRef()](/api/reactivity-utilities#toref) utility APIs:
+Se hai davvero bisogno di destrutturare le props o devi passare una prop a una funzione esterna mantenendo la reattività, puoi farlo utilizzando le API [toRefs()](./reactivity-utilities#torefs) e [toRef()](/api/reactivity-utilities#toref):
 
 ```js
 import { toRefs, toRef } from 'vue'
 
 export default {
   setup(props) {
-    // turn `props` into an object of refs, then destructure
+    // trasforma `props` in un oggetto di refs, poi destruttura
     const { title } = toRefs(props)
-    // `title` is a ref that tracks `props.title`
+    // `title` è un ref che tiene traccia di `props.title`
     console.log(title.value)
 
-    // OR, turn a single property on `props` into a ref
+    // OPPURE, trasforma una singola proprietà in `props` in un ref
     const title = toRef(props, 'title')
   }
 }
@@ -81,27 +81,27 @@ export default {
 
 ## Setup Context {#setup-context}
 
-The second argument passed to the `setup` function is a **Setup Context** object. The context object exposes other values that may be useful inside `setup`:
+Il secondo argomento passato alla funzione `setup` è un oggetto di **Context Setup**. L'oggetto context espone altri valori che potrebbero essere utili all'interno di `setup`:
 
 ```js
 export default {
   setup(props, context) {
-    // Attributes (Non-reactive object, equivalent to $attrs)
+    // Attributi (Oggetto non reattivo, equivalente a $attrs)
     console.log(context.attrs)
 
-    // Slots (Non-reactive object, equivalent to $slots)
+    // Slots (Oggetto non reattivo, equivalente a $slots)
     console.log(context.slots)
 
-    // Emit events (Function, equivalent to $emit)
+    // Eventi Emit (Funzione, equivalente a $emit)
     console.log(context.emit)
 
-    // Expose public properties (Function)
+    // Esporre proprietà pubbliche (Funzione)
     console.log(context.expose)
   }
 }
 ```
 
-The context object is not reactive and can be safely destructured:
+L'oggetto context non è reattivo e può essere destrutturato in modo sicuro:
 
 ```js
 export default {
@@ -111,30 +111,30 @@ export default {
 }
 ```
 
-`attrs` and `slots` are stateful objects that are always updated when the component itself is updated. This means you should avoid destructuring them and always reference properties as `attrs.x` or `slots.x`. Also note that, unlike `props`, the properties of `attrs` and `slots` are **not** reactive. If you intend to apply side effects based on changes to `attrs` or `slots`, you should do so inside an `onBeforeUpdate` lifecycle hook.
+`attrs` e `slots` sono stateful objects che vengono sempre aggiornati quando il componente stesso viene aggiornato. Questo significa che dovresti evitare di destrutturarli e fare sempre riferimento alle proprietà come `attrs.x` o `slots.x`. Inoltre, nota che, a differenza di `props`, le proprietà di `attrs` e `slots` **non** sono reattive. Se hai l'intenzione di applicare effetti collaterali basati su modifiche a `attrs` o `slots`, dovresti farlo all'interno di un hook del ciclo di vita `onBeforeUpdate`.
 
-### Exposing Public Properties {#exposing-public-properties}
+### Esporre Proprietà Pubbliche {#exposing-public-properties}
 
-`expose` is a function that can be used to explicitly limit the properties exposed when the component instance is accessed by a parent component via [template refs](/guide/essentials/template-refs#ref-on-component):
+`expose` è una funzione che può essere utilizzata per limitare esplicitamente le proprietà esposte quando l'istanza del componente è caricata da un componente genitore tramite [template refs](/guide/essentials/template-refs#ref-on-component):
 
 ```js{5,10}
 export default {
   setup(props, { expose }) {
-    // make the instance "closed" -
-    // i.e. do not expose anything to the parent
+    // rendi l'istanza "chiusa" -
+    // cioè, non esporre nulla al componente genitore
     expose()
 
     const publicCount = ref(0)
     const privateCount = ref(0)
-    // selectively expose local state
+    // espone selettivamente lo stato locale
     expose({ count: publicCount })
   }
 }
 ```
 
-## Usage with Render Functions {#usage-with-render-functions}
+## Uso con Funzioni di Rendering {#usage-with-render-functions}
 
-`setup` can also return a [render function](/guide/extras/render-function) which can directly make use of the reactive state declared in the same scope:
+`setup` può anche restituire una [funzione di rendering](/guide/extras/render-function) che può utilizzare direttamente lo stato reattivo dichiarato nello stesso scope:
 
 ```js{6}
 import { h, ref } from 'vue'
@@ -147,9 +147,9 @@ export default {
 }
 ```
 
-Returning a render function prevents us from returning anything else. Internally that shouldn't be a problem, but it can be problematic if we want to expose methods of this component to the parent component via template refs.
+Restituire una funzione di rendering impedisce di restituire qualsiasi altra cosa. Internamente questo non dovrebbe essere un problema, ma può essere problematico se vogliamo esporre metodi di questo componente al componente genitore tramite i refs del template.
 
-We can solve this problem by calling [`expose()`](#exposing-public-properties):
+Possiamo risolvere questo problema chiamando [`expose()`](#exposing-public-properties):
 
 ```js{8-10}
 import { h, ref } from 'vue'
@@ -168,4 +168,4 @@ export default {
 }
 ```
 
-The `increment` method would then be available in the parent component via a template ref.
+Il metodo `increment` sarebbe quindi disponibile nel componente genitore tramite un riferimento al template.

From 38859aec10d424c4331082ebb1bc61d8a8125e7e Mon Sep 17 00:00:00 2001
From: Paolo Dadda <ilpaolino@gmail.com>
Date: Wed, 6 Sep 2023 19:51:32 +0200
Subject: [PATCH 2/5] docs: composition-api-lifecycle translation

---
 src/api/composition-api-lifecycle.md | 181 +++++++++++++--------------
 1 file changed, 90 insertions(+), 91 deletions(-)

diff --git a/src/api/composition-api-lifecycle.md b/src/api/composition-api-lifecycle.md
index 637c4faa..0aa9a7c6 100644
--- a/src/api/composition-api-lifecycle.md
+++ b/src/api/composition-api-lifecycle.md
@@ -1,12 +1,12 @@
-# Composition API: Lifecycle Hooks {#composition-api-lifecycle-hooks}
+# Composition API: Hook del Ciclo di Vita {#composition-api-lifecycle-hooks}
 
 :::info Usage Note
-All APIs listed on this page must be called synchronously during the `setup()` phase of a component. See [Guide - Lifecycle Hooks](/guide/essentials/lifecycle) for more details.
+Tutte le API elencate in questa pagina devono essere chiamate sincronamente durante la fase `setup()` di un componente. Vedi [Guida - Hook del Ciclo di Vita](/guide/essentials/lifecycle) per maggiori dettagli.
 :::
 
 ## onMounted() {#onmounted}
 
-Registers a callback to be called after the component has been mounted.
+Registra una funzione di callback da eseguire dopo che il componente è stato montato.
 
 - **Type**
 
@@ -16,19 +16,19 @@ Registers a callback to be called after the component has been mounted.
 
 - **Details**
 
-  A component is considered mounted after:
+  Un componente è considerato montato dopo che:
 
-  - All of its synchronous child components have been mounted (does not include async components or components inside `<Suspense>` trees).
+  - Tutti i suoi componenti figlio sincroni sono stati montati (non include componenti asincroni o componenti all'interno di alberi `<Suspense>`).
 
-  - Its own DOM tree has been created and inserted into the parent container. Note it only guarantees that the component's DOM tree is in-document if the application's root container is also in-document.
+  - L'albero del suo DOM è stato creato e inserito nel contenitore padre. Nota: è garantito solo che l'albero DOM del componente sia nel documento se anche il contenitore nella root dell'applicazione è nel documento.
 
-  This hook is typically used for performing side effects that need access to the component's rendered DOM, or for limiting DOM-related code to the client in a [server-rendered application](/guide/scaling-up/ssr).
+  Questo hook è tipicamente utilizzato per eseguire effetti collaterali che hanno accesso al DOM renderizzato del componente, o per limitare il codice correlato al DOM al client in un'applicazione [renderizzata lato server](/guide/scaling-up/ssr).
 
-  **This hook is not called during server-side rendering.**
+  **Questo hook non viene chiamato durante il rendering lato server.**
 
-- **Example**
+- **Esempio**
 
-  Accessing an element via template ref:
+  Accesso ad un elemento tramite ref al template:
 
   ```vue
   <script setup>
@@ -48,29 +48,29 @@ Registers a callback to be called after the component has been mounted.
 
 ## onUpdated() {#onupdated}
 
-Registers a callback to be called after the component has updated its DOM tree due to a reactive state change.
+Registra una callback da chiamare dopo che il componente ha aggiornato il suo albero DOM a causa di un cambiamento di stato reattivo.
 
-- **Type**
+- **Tipo**
 
   ```ts
   function onUpdated(callback: () => void): void
   ```
 
-- **Details**
+- **Dettagli**
 
-  A parent component's updated hook is called after that of its child components.
+  L'hook di aggiornamento del componente padre viene chiamato dopo quello dei suoi componenti figli.
 
-  This hook is called after any DOM update of the component, which can be caused by different state changes, because multiple state changes can be batched into a single render cycle for performance reasons. If you need to access the updated DOM after a specific state change, use [nextTick()](/api/general#nexttick) instead.
+  Questo hook viene chiamato dopo ogni aggiornamento del DOM del componente, che può essere causato da diversi cambiamenti di stato, poiché più cambiamenti di stato possono essere raggruppati in un singolo ciclo di rendering per motivi di prestazioni. Se è necessario accedere al DOM aggiornato dopo un cambiamento di stato specifico, usare [nextTick()](/api/general#nexttick) al suo posto.
 
-  **This hook is not called during server-side rendering.**
+  **Questo hook non viene chiamato durante il rendering lato server.**
 
   :::warning
-  Do not mutate component state in the updated hook - this will likely lead to an infinite update loop!
+  Evita di mutare lo stato del componente nell'hook di aggiornamento, poiché ciò probabilmente porterà a un ciclo di aggiornamento infinito!
   :::
 
-- **Example**
+- **Esempio**
 
-  Accessing updated DOM:
+  Accesso al DOM aggiornato:
 
   ```vue
   <script setup>
@@ -79,7 +79,7 @@ Registers a callback to be called after the component has updated its DOM tree d
   const count = ref(0)
 
   onUpdated(() => {
-    // text content should be the same as current `count.value`
+   // Il contenuto del testo dovrebbe essere lo stesso di `count.value` attuale
     console.log(document.getElementById('count').textContent)
   })
   </script>
@@ -91,27 +91,27 @@ Registers a callback to be called after the component has updated its DOM tree d
 
 ## onUnmounted() {#onunmounted}
 
-Registers a callback to be called after the component has been unmounted.
+Registra una callback da chiamare dopo che il componente è stato smontato.
 
-- **Type**
+- **Tipo**
 
   ```ts
   function onUnmounted(callback: () => void): void
   ```
 
-- **Details**
+- **Dettagli**
 
-  A component is considered unmounted after:
+  Un componente viene considerato smontato dopo:
 
-  - All of its child components have been unmounted.
+  - Tutti i suoi componenti figli sono stati smontati.
 
-  - All of its associated reactive effects (render effect and computed / watchers created during `setup()`) have been stopped.
+  - Tutti i suoi effetti reattivi associati (effetto di render e computed / watcher creati durante `setup()`) sono stati interrotti.
 
-  Use this hook to clean up manually created side effects such as timers, DOM event listeners or server connections.
+  Utilizzare questo hook per azzerare manualmente gli effetti collaterali creati, come timer, gestori di eventi DOM o connessioni server.
 
-  **This hook is not called during server-side rendering.**
+  **Questo hook non viene chiamato durante il rendering lato server.**
 
-- **Example**
+- **Esempio**
 
   ```vue
   <script setup>
@@ -130,57 +130,57 @@ Registers a callback to be called after the component has been unmounted.
 
 ## onBeforeMount() {#onbeforemount}
 
-Registers a hook to be called right before the component is to be mounted.
+Registra un hook da chiamare proprio prima che il componente debba essere montato.
 
-- **Type**
+- **Tipo**
 
   ```ts
   function onBeforeMount(callback: () => void): void
   ```
 
-- **Details**
+- **Dettagli**
 
-  When this hook is called, the component has finished setting up its reactive state, but no DOM nodes have been created yet. It is about to execute its DOM render effect for the first time.
+  Quando questo hook viene chiamato, il componente ha completato la configurazione del suo stato reattivo, ma ancora nessun nodo è stato creato nel DOM. Sta per eseguire il suo effetto di render del DOM per la prima volta.
 
-  **This hook is not called during server-side rendering.**
+  **Questo hook non viene chiamato durante il rendering lato server.**
 
 ## onBeforeUpdate() {#onbeforeupdate}
 
-Registers a hook to be called right before the component is about to update its DOM tree due to a reactive state change.
+Registra un hook da chiamare proprio prima che il componente aggiorni il suo albero DOM a causa di un cambiamento di stato reattivo.
 
-- **Type**
+- **Tipo**
 
   ```ts
   function onBeforeUpdate(callback: () => void): void
   ```
 
-- **Details**
+- **Dettagli**
 
-  This hook can be used to access the DOM state before Vue updates the DOM. It is also safe to modify component state inside this hook.
+  Questo hook può essere utilizzato per accedere allo stato del DOM prima che Vue aggiorni il DOM. È anche sicuro modificare lo stato del componente all'interno di questo hook.
 
-  **This hook is not called during server-side rendering.**
+  **Questo hook non viene chiamato durante il rendering lato server.**
 
 ## onBeforeUnmount() {#onbeforeunmount}
 
-Registers a hook to be called right before a component instance is to be unmounted.
+Registra un hook da chiamare proprio prima che un'istanza del componente debba essere smontata.
 
-- **Type**
+- **Tipo**
 
   ```ts
   function onBeforeUnmount(callback: () => void): void
   ```
 
-- **Details**
+- **Dettagli**
 
-  When this hook is called, the component instance is still fully functional.
+  Quando questo hook viene chiamato, l'istanza del componente è ancora completamente funzionante.
 
-  **This hook is not called during server-side rendering.**
+  **Questo hook non viene chiamato durante il rendering lato server.**
 
 ## onErrorCaptured() {#onerrorcaptured}
 
-Registers a hook to be called when an error propagating from a descendant component has been captured.
+Registra un hook da chiamare quando un errore propagato da un componente discendente è stato catturato.
 
-- **Type**
+- **Tipo**
 
   ```ts
   function onErrorCaptured(callback: ErrorCapturedHook): void
@@ -192,41 +192,41 @@ Registers a hook to be called when an error propagating from a descendant compon
   ) => boolean | void
   ```
 
-- **Details**
+- **Dettagli**
 
-  Errors can be captured from the following sources:
+  Gli errori possono essere catturati dalle seguenti fonti:
 
-  - Component renders
-  - Event handlers
-  - Lifecycle hooks
-  - `setup()` function
-  - Watchers
-  - Custom directive hooks
-  - Transition hooks
+  - Render del componente
+  - Gestore di eventi
+  - Hook del ciclo di vita
+  - Funzione `setup()`
+  - I Watcher
+  - Hook personalizzati delle direttive
+  - Hook delle transizioni
 
-  The hook receives three arguments: the error, the component instance that triggered the error, and an information string specifying the error source type.
+  L'hook riceve tre argomenti: l'errore, l'istanza del componente che ha generato l'errore e una stringa di informazione che specifica il tipo di origine dell'errore.
 
-  You can modify component state in `errorCaptured()` to display an error state to the user. However, it is important that the error state should not render the original content that caused the error; otherwise the component will be thrown into an infinite render loop.
+  Puoi modificare lo stato del componente in `errorCaptured()` per mostrare uno stato di errore all'utente. Tuttavia, è importante che lo stato di errore non renderizzi il contenuto originale che ha causato l'errore; altrimenti il componente entrerà in un ciclo di rendering infinito.
 
-  The hook can return `false` to stop the error from propagating further. See error propagation details below.
+  L'hook può restituire `false` per impedire alla propagazione dell'errore. Vedi i dettagli sulla propagazione degli errori di seguito.
 
-  **Error Propagation Rules**
+  **Regole di Propagazione degli Errori**
 
-  - By default, all errors are still sent to the application-level [`app.config.errorHandler`](/api/application#app-config-errorhandler) if it is defined, so that these errors can still be reported to an analytics service in a single place.
+  - Per impostazione predefinita, tutti gli errori vengono comunque inviati all'handler delle applicazioni [`app.config.errorHandler`](/api/application#app-config-errorhandler) se è definito, in modo che questi errori possano ancora essere segnalati ad un servizio di analytics in un unico punto.
 
-  - If multiple `errorCaptured` hooks exist on a component's inheritance chain or parent chain, all of them will be invoked on the same error, in the order of bottom to top. This is similar to the bubbling mechanism of native DOM events.
+  - Se esistono più hook `errorCaptured` nella catena di ereditarietà di un componente o nella catena dei padri, tutti saranno invocati per lo stesso errore, in ordine dal basso verso l'alto. Questo è simile al meccanismo di propagazione degli eventi DOM nativi.
 
-  - If the `errorCaptured` hook itself throws an error, both this error and the original captured error are sent to `app.config.errorHandler`.
+  - Se l'hook `errorCaptured` stesso genera un errore, sia quest'ultimo errore che l'errore originale vengono inviati a `app.config.errorHandler`.
 
-  - An `errorCaptured` hook can return `false` to prevent the error from propagating further. This is essentially saying "this error has been handled and should be ignored." It will prevent any additional `errorCaptured` hooks or `app.config.errorHandler` from being invoked for this error.
+  - Un hook `errorCaptured` può restituire `false` per impedire la propagazione dell'errore. Questo equivale a dire "questo errore è stato gestito e dovrebbe essere ignorato". Ciò impedirà che vengano invocati ulteriori hook `errorCaptured` o `app.config.errorHandler` per questo errore.
 
 ## onRenderTracked() <sup class="vt-badge dev-only" /> {#onrendertracked}
 
-Registers a debug hook to be called when a reactive dependency has been tracked by the component's render effect.
+Registra un hook di debug da chiamare quando una dipendenza reattiva è stata tracciata dall'effetto di render del componente.
 
-**This hook is development-mode-only and not called during server-side rendering.**
+**Questo hook è disponibile solo in modalità di sviluppo e non viene chiamato durante il rendering lato server.**
 
-- **Type**
+- **Tipo**
 
   ```ts
   function onRenderTracked(callback: DebuggerHook): void
@@ -241,15 +241,15 @@ Registers a debug hook to be called when a reactive dependency has been tracked
   }
   ```
 
-- **See also** [Reactivity in Depth](/guide/extras/reactivity-in-depth)
+- **Vedi anche** [Reactivity in Depth](/guide/extras/reactivity-in-depth)
 
 ## onRenderTriggered() <sup class="vt-badge dev-only" /> {#onrendertriggered}
 
-Registers a debug hook to be called when a reactive dependency triggers the component's render effect to be re-run.
+Registra un hook di debug da chiamare quando una dipendenza reattiva scatena nuovamente l'effetto di render del componente.
 
-**This hook is development-mode-only and not called during server-side rendering.**
+**Questo hook è disponibile solo in modalità di sviluppo e non viene chiamato durante il rendering lato server.**
 
-- **Type**
+- **Tipo**
 
   ```ts
   function onRenderTriggered(callback: DebuggerHook): void
@@ -267,53 +267,53 @@ Registers a debug hook to be called when a reactive dependency triggers the comp
   }
   ```
 
-- **See also** [Reactivity in Depth](/guide/extras/reactivity-in-depth)
+- **Vedi anche** [Reactivity in Depth](/guide/extras/reactivity-in-depth)
 
 ## onActivated() {#onactivated}
 
-Registers a callback to be called after the component instance is inserted into the DOM as part of a tree cached by [`<KeepAlive>`](/api/built-in-components#keepalive).
+Registra una callback da chiamare dopo che l'istanza del componente è stata inserita nel DOM come parte di un albero memorizzato in cache da [`<KeepAlive>`](/api/built-in-components#keepalive).
 
-**This hook is not called during server-side rendering.**
+**Questo hook non viene chiamato durante il rendering lato server.**
 
-- **Type**
+- **Tipo**
 
   ```ts
   function onActivated(callback: () => void): void
   ```
 
-- **See also** [Guide - Lifecycle of Cached Instance](/guide/built-ins/keep-alive#lifecycle-of-cached-instance)
+- **Vedi anche** [Guide - Lifecycle of Cached Instance](/guide/built-ins/keep-alive#lifecycle-of-cached-instance)
 
 ## onDeactivated() {#ondeactivated}
 
-Registers a callback to be called after the component instance is removed from the DOM as part of a tree cached by [`<KeepAlive>`](/api/built-in-components#keepalive).
+Registra una callback da chiamare dopo che l'istanza del componente è stata rimossa dal DOM come parte di un albero memorizzato in cache da [`<KeepAlive>`](/api/built-in-components#keepalive).
 
-**This hook is not called during server-side rendering.**
+**Questo hook non viene chiamato durante il rendering lato server.**
 
-- **Type**
+- **Tipo**
 
   ```ts
   function onDeactivated(callback: () => void): void
   ```
 
-- **See also** [Guide - Lifecycle of Cached Instance](/guide/built-ins/keep-alive#lifecycle-of-cached-instance)
+- **Vedi anche** [Guide - Lifecycle of Cached Instance](/guide/built-ins/keep-alive#lifecycle-of-cached-instance)
 
 ## onServerPrefetch() <sup class="vt-badge" data-text="SSR only" /> {#onserverprefetch}
 
-Registers an async function to be resolved before the component instance is to be rendered on the server.
+Registra una funzione asincrona da risolvere prima che l'istanza del componente debba essere renderizzata sul server.
 
-- **Type**
+- **Tipo**
 
   ```ts
   function onServerPrefetch(callback: () => Promise<any>): void
   ```
 
-- **Details**
+- **Dettagli**
 
-  If the callback returns a Promise, the server renderer will wait until the Promise is resolved before rendering the component.
+  Se la callback restituisce una Promise, il renderer sul server aspetterà che la Promise venga risolta prima di renderizzare il componente.
 
-  This hook is only called during server-side rendering can be used to perform server-only data fetching.
+  Questo hook viene chiamato solo durante il rendering lato server ed è utilizzato per eseguire il recupero di dati specifico del server.
 
-- **Example**
+- **Esempio**
 
   ```vue
   <script setup>
@@ -322,20 +322,19 @@ Registers an async function to be resolved before the component instance is to b
   const data = ref(null)
 
   onServerPrefetch(async () => {
-    // component is rendered as part of the initial request
-    // pre-fetch data on server as it is faster than on the client
+    // il componente viene renderizzato come parte della richiesta iniziale
+    // effettua il pre-recupero dei dati sul server poiché è più veloce che farlo sul client
     data.value = await fetchOnServer(/* ... */)
   })
 
   onMounted(async () => {
     if (!data.value) {
-      // if data is null on mount, it means the component
-      // is dynamically rendered on the client. Perform a
-      // client-side fetch instead.
+      // se i dati sono nulli al momento del montaggio, significa che il componente
+      // viene renderizzato dinamicamente sul client. Esegui il recupero sul lato client.
       data.value = await fetchOnClient(/* ... */)
     }
   })
   </script>
   ```
 
-- **See also** [Server-Side Rendering](/guide/scaling-up/ssr)
+- **Vedi anche** [Server-Side Rendering](/guide/scaling-up/ssr)

From 376be3370b11db66abdf0e744397bedecb7dfb82 Mon Sep 17 00:00:00 2001
From: Paolo Dadda <ilpaolino@gmail.com>
Date: Wed, 6 Sep 2023 22:02:30 +0200
Subject: [PATCH 3/5] docs: composition-api-dependency-injection translation

---
 .../composition-api-dependency-injection.md   | 68 +++++++++----------
 1 file changed, 34 insertions(+), 34 deletions(-)

diff --git a/src/api/composition-api-dependency-injection.md b/src/api/composition-api-dependency-injection.md
index b5d5fc79..f67b1192 100644
--- a/src/api/composition-api-dependency-injection.md
+++ b/src/api/composition-api-dependency-injection.md
@@ -2,59 +2,59 @@
 
 ## provide() {#provide}
 
-Provides a value that can be injected by descendant components.
+Fornisce un valore che può essere iniettato dai componenti discendenti.
 
-- **Type**
+- **Tipo**
 
   ```ts
   function provide<T>(key: InjectionKey<T> | string, value: T): void
   ```
 
-- **Details**
+- **Dettagli**
 
-  `provide()` takes two arguments: the key, which can be a string or a symbol, and the value to be injected.
+  `provide()` richiede due argomenti: la chiave, che può essere una stringa o un simbolo, e il valore da iniettare.
 
-  When using TypeScript, the key can be a symbol casted as `InjectionKey` - a Vue provided utility type that extends `Symbol`, which can be used to sync the value type between `provide()` and `inject()`.
+  Quando si utilizza TypeScript, la chiave può essere un simbolo convertito in `InjectionKey` - un tipo di utilità fornito da Vue che estende `Symbol`, il quale può essere utilizzato per sincronizzare il tipo di valore tra `provide()` e `inject()`.
 
-  Similar to lifecycle hook registration APIs, `provide()` must be called synchronously during a component's `setup()` phase.
+  Simile alle API di registrazione dei hook del ciclo di vita, `provide()` deve essere chiamato sincronamente durante la fase `setup()` di un componente.
 
-- **Example**
+- **Esempio**
 
   ```vue
   <script setup>
   import { ref, provide } from 'vue'
   import { fooSymbol } from './injectionSymbols'
 
-  // provide static value
+  // fornire un valore statico
   provide('foo', 'bar')
 
-  // provide reactive value
+  // fornire un valore reattivo
   const count = ref(0)
   provide('count', count)
 
-  // provide with Symbol keys
+  // fornire con chiavi di tipo Symbol
   provide(fooSymbol, count)
   </script>
   ```
 
-- **See also**
+- **Vedi anche**
   - [Guide - Provide / Inject](/guide/components/provide-inject)
   - [Guide - Typing Provide / Inject](/guide/typescript/composition-api#typing-provide-inject) <sup class="vt-badge ts" />
 
 ## inject() {#inject}
 
-Injects a value provided by an ancestor component or the application (via `app.provide()`).
+Inietta un valore fornito da un componente ascendente o dall'applicazione (tramite `app.provide()`).
 
-- **Type**
+- **Tipo**
 
   ```ts
-  // without default value
+  // senza valore predefinito
   function inject<T>(key: InjectionKey<T> | string): T | undefined
 
-  // with default value
+  // con valore predefinito
   function inject<T>(key: InjectionKey<T> | string, defaultValue: T): T
 
-  // with factory
+  // con factory
   function inject<T>(
     key: InjectionKey<T> | string,
     defaultValue: () => T,
@@ -62,47 +62,47 @@ Injects a value provided by an ancestor component or the application (via `app.p
   ): T
   ```
 
-- **Details**
+- **Dettagli**
 
-  The first argument is the injection key. Vue will walk up the parent chain to locate a provided value with a matching key. If multiple components in the parent chain provides the same key, the one closest to the injecting component will "shadow" those higher up the chain. If no value with matching key was found, `inject()` returns `undefined` unless a default value is provided.
+  Il primo argomento è la injection key. Vue risalirà la catena dei padri per individuare un valore fornito con una chiave corrispondente. Se più componenti nella catena dei padri forniscono la stessa chiave, quello più vicino alla injection key "oscurerà" quelli più in alto nella catena. Se non viene trovato alcun valore con chiave corrispondente, `inject()` restituirà `undefined`, a meno che non venga fornito un valore predefinito.
 
-  The second argument is optional and is the default value to be used when no matching value was found.
+  Il secondo argomento è opzionale ed è il valore predefinito da utilizzare quando non viene trovato alcun valore corrispondente.
 
-  The second argument can also be a factory function that returns values that are expensive to create. In this case, `true` must be passed as the third argument to indicate that the function should be used as a factory instead of the value itself.
+  Il secondo argomento può anche essere una funzione factory che restituisce valori costosi da creare. In questo caso, il terzo argomento deve essere passato come `true` per indicare che la funzione deve essere utilizzata come una factory anziché il valore stesso.
 
-  Similar to lifecycle hook registration APIs, `inject()` must be called synchronously during a component's `setup()` phase.
+  Simile alle API di registrazione dei lifecycle hook, `inject()` deve essere chiamato in modo sincrono durante la fase `setup()` di un componente.
 
-  When using TypeScript, the key can be of type of `InjectionKey` - a Vue-provided utility type that extends `Symbol`, which can be used to sync the value type between `provide()` and `inject()`.
+  Quando si utilizza TypeScript, la chiave può essere del tipo `InjectionKey` - un tipo di utilità fornito da Vue che estende `Symbol`, che può essere utilizzato per sincronizzare il tipo di valore tra `provide()` e `inject()`.
 
-- **Example**
+- **Esempio**
 
-  Assuming a parent component has provided values as shown in the previous `provide()` example:
+  Supponeniamo che un componente padre abbia fornito valori come mostrato nell'esempio precedente di `provide()`:
 
   ```vue
   <script setup>
   import { inject } from 'vue'
   import { fooSymbol } from './injectionSymbols'
 
-  // inject static value without default
+  // inietta un valore statico senza default
   const foo = inject('foo')
 
-  // inject reactive value
+  // inietta un valore reattivo
   const count = inject('count')
 
-  // inject with Symbol keys
+  // inietta con chiavi Symbol
   const foo2 = inject(fooSymbol)
 
-  // inject with default value
-  const bar = inject('foo', 'default value')
+  // inietta con valore predefinito
+  const bar = inject('foo', 'valore predefinito')
 
-  // inject with function default value
-  const fn = inject('function', () => {})
+  // inietta con valore predefinito funzione
+  const fn = inject('funzione', () => {})
 
-  // inject with default value factory
-  const baz = inject('factory', () => new ExpensiveObject(), true)
+  // inietta con fabbrica di valore predefinito
+  const baz = inject('fabbrica', () => new OggettoCostoso(), true)
   </script>
   ```
 
-- **See also**
+- **Vedi anche**
   - [Guide - Provide / Inject](/guide/components/provide-inject)
   - [Guide - Typing Provide / Inject](/guide/typescript/composition-api#typing-provide-inject) <sup class="vt-badge ts" />

From f29b0fa668ef17ae6b3d6a8aef6dd3c20b2b54d0 Mon Sep 17 00:00:00 2001
From: Paolo Dadda <ilpaolino@gmail.com>
Date: Mon, 2 Oct 2023 23:17:54 +0200
Subject: [PATCH 4/5] docs: reactivity-utilities translation

---
 src/api/reactivity-utilities.md | 110 ++++++++++++++++----------------
 1 file changed, 55 insertions(+), 55 deletions(-)

diff --git a/src/api/reactivity-utilities.md b/src/api/reactivity-utilities.md
index 7732864f..612f57ab 100644
--- a/src/api/reactivity-utilities.md
+++ b/src/api/reactivity-utilities.md
@@ -2,53 +2,53 @@
 
 ## isRef() {#isref}
 
-Checks if a value is a ref object.
+Verifica se un valore è un oggetto ref.
 
-- **Type**
+- **Tipo**
 
   ```ts
   function isRef<T>(r: Ref<T> | unknown): r is Ref<T>
   ```
 
-  Note the return type is a [type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates), which means `isRef` can be used as a type guard:
+  Nota: il tipo di ritorno è un [type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates), il che significa che `isRef` può essere utilizzato come type guard:
 
   ```ts
   let foo: unknown
   if (isRef(foo)) {
-    // foo's type is narrowed to Ref<unknown>
+    // il tipo di foo è ora limitato a Ref<unknown>
     foo.value
   }
   ```
 
 ## unref() {#unref}
 
-Returns the inner value if the argument is a ref, otherwise return the argument itself. This is a sugar function for `val = isRef(val) ? val.value : val`.
+Restituisce il valore interno se l'argomento è un ref, altrimenti restituisce l'argomento stesso. Questa è una funzione di "zucchero sintattico" equivalente a `val = isRef(val) ? val.value : val`.
 
-- **Type**
+- **Tipo**
 
   ```ts
   function unref<T>(ref: T | Ref<T>): T
   ```
 
-- **Example**
+- **Esempio**
 
   ```ts
   function useFoo(x: number | Ref<number>) {
     const unwrapped = unref(x)
-    // unwrapped is guaranteed to be number now
+    // unwrapped è certo che sia ora un numero
   }
   ```
 
 ## toRef() {#toref}
 
-Can be used to normalize values / refs / getters into refs (3.3+).
+Può essere utilizzato per normalizzare value / ref / getter nei ref (3.3+).
 
-Can also be used to create a ref for a property on a source reactive object. The created ref is synced with its source property: mutating the source property will update the ref, and vice-versa.
+Può anche essere utilizzato per creare un ref per una proprietà su un oggetto reattivo sorgente. Il ref creato è sincronizzato con la proprietà di origine: la modifica della proprietà di origine aggiornerà il ref e viceversa.
 
-- **Type**
+- **Tipo**
 
   ```ts
-  // normalization signature (3.3+)
+  // firma di normalizzazione (3.3+)
   function toRef<T>(
     value: T
   ): T extends () => infer R
@@ -57,7 +57,7 @@ Can also be used to create a ref for a property on a source reactive object. The
     ? T
     : Ref<UnwrapRef<T>>
 
-  // object property signature
+  // firma della proprietà dell'oggetto
   function toRef<T extends object, K extends keyof T>(
     object: T,
     key: K,
@@ -67,23 +67,23 @@ Can also be used to create a ref for a property on a source reactive object. The
   type ToRef<T> = T extends Ref ? T : Ref<T>
   ```
 
-- **Example**
+- **Esempio**
 
-  Normalization signature (3.3+):
+  Firma di normalizzazione (3.3+):
 
   ```js
-  // returns existing refs as-is
+  // restituisce i ref esistenti così come sono
   toRef(existingRef)
 
-  // creates a readonly ref that calls the getter on .value access
+  // crea un ref in sola lettura che chiama il getter su accesso a .value
   toRef(() => props.foo)
 
-  // creates normal refs from non-function values
-  // equivalent to ref(1)
+  // crea ref normali da valori non funzione
+  // equivalente a ref(1)
   toRef(1)
   ```
 
-  Object property signature:
+  Firma della proprietà dell'oggetto:
 
   ```js
   const state = reactive({
@@ -91,27 +91,27 @@ Can also be used to create a ref for a property on a source reactive object. The
     bar: 2
   })
 
-  // a two-way ref that syncs with the original property
+  // un ref bidirezionale che si sincronizza con la proprietà originale
   const fooRef = toRef(state, 'foo')
 
-  // mutating the ref updates the original
+  // la modifica del ref aggiorna l'originale
   fooRef.value++
   console.log(state.foo) // 2
 
-  // mutating the original also updates the ref
+  // la modifica dell'originale aggiorna anche il ref
   state.foo++
   console.log(fooRef.value) // 3
   ```
 
-  Note this is different from:
+  Nota che ciò è diverso da:
 
   ```js
   const fooRef = ref(state.foo)
   ```
 
-  The above ref is **not** synced with `state.foo`, because the `ref()` receives a plain number value.
+  Il ref sopra **non** è sincronizzato con `state.foo`, perchè `ref()` riceve un valore numerico semplice.
 
-  `toRef()` is useful when you want to pass the ref of a prop to a composable function:
+  `toRef()`  è utile quando si desidera passare il ref di una prop a una funzione composable:
 
   ```vue
   <script setup>
@@ -119,32 +119,32 @@ Can also be used to create a ref for a property on a source reactive object. The
 
   const props = defineProps(/* ... */)
 
-  // convert `props.foo` into a ref, then pass into
-  // a composable
+  // converti `props.foo` in un ref, poi passalo a
+  // una funzione componibile
   useSomeFeature(toRef(props, 'foo'))
 
-  // getter syntax - recommended in 3.3+
+  // sintassi getter - consigliata in 3.3+
   useSomeFeature(toRef(() => props.foo))
   </script>
   ```
 
-  When `toRef` is used with component props, the usual restrictions around mutating the props still apply. Attempting to assign a new value to the ref is equivalent to trying to modify the prop directly and is not allowed. In that scenario you may want to consider using [`computed`](./reactivity-core#computed) with `get` and `set` instead. See the guide to [using `v-model` with components](/guide/components/v-model) for more information.
+  Quando `toRef` viene utilizzato con le prop del componente, si applicano comunque le solite restrizioni sulla modifica delle prop. Tentare di assegnare un nuovo valore al ref è equivalente a cercare di modificare direttamente la prop e non è consentito. In questo scenario potrebbe essere utile considerare l'uso di [`computed`](./reactivity-core#computed) con `get` e `set` al loro posto. Consulta la guida su [usare `v-model` con i componenti](/guide/components/v-model) per maggiori informazioni.
 
-  When using the object property signature, `toRef()` will return a usable ref even if the source property doesn't currently exist. This makes it possible to work with optional properties, which wouldn't be picked up by [`toRefs`](#torefs).
+  Quando viene utilizzata la firma della proprietà dell'oggetto, `toRef()`restituirà un ref utilizzabile anche se la proprietà di origine non esiste attualmente. Ciò consente di lavorare con proprietà opzionali, che non verrebbero rilevate da [`toRefs`](#torefs).
 
 ## toValue() <sup class="vt-badge" data-text="3.3+" /> {#tovalue}
 
-Normalizes values / refs / getters to values. This is similar to [unref()](#unref), except that it also normalizes getters. If the argument is a getter, it will be invoked and its return value will be returned.
+Normalizza valori / ref / getter in valori. Questo è simile a [unref()](#unref), tranne che normalizza anche i getter. Se l'argomento è un getter, verrà invocato e il suo valore di ritorno verrà restituito.
 
-This can be used in [Composables](/guide/reusability/composables.html) to normalize an argument that can be either a value, a ref, or a getter.
+Può essere utilizzato nei [Composables](/guide/reusability/composables.html) per normalizzare un argomento che può essere un valore, un ref o un getter.
 
-- **Type**
+- **Tipo**
 
   ```ts
   function toValue<T>(source: T | Ref<T> | (() => T)): T
   ```
 
-- **Example**
+- **Esempio**
 
   ```js
   toValue(1) //       --> 1
@@ -152,18 +152,18 @@ This can be used in [Composables](/guide/reusability/composables.html) to normal
   toValue(() => 1) // --> 1
   ```
 
-  Normalizing arguments in composables:
+  Normalizzazione degli argomenti nei composables:
 
   ```ts
   import type { MaybeRefOrGetter } from 'vue'
 
   function useFeature(id: MaybeRefOrGetter<number>) {
     watch(() => toValue(id), id => {
-      // react to id changes
+      // reagisce ai cambiamenti di id
     })
   }
 
-  // this composable supports any of the following:
+  // questo composable supporta uno qualsiasi dei seguenti:
   useFeature(1)
   useFeature(ref(1))
   useFeature(() => 1)
@@ -171,9 +171,9 @@ This can be used in [Composables](/guide/reusability/composables.html) to normal
 
 ## toRefs() {#torefs}
 
-Converts a reactive object to a plain object where each property of the resulting object is a ref pointing to the corresponding property of the original object. Each individual ref is created using [`toRef()`](#toref).
+Converte un oggetto reattivo in un oggetto semplice in cui ogni proprietà dell'oggetto risultante è un ref che punta alla corrispondente proprietà dell'oggetto originale. Ciascun ref individuale è creato utilizzando [`toRef()`](#toref).
 
-- **Type**
+- **Tipo**
 
   ```ts
   function toRefs<T extends object>(
@@ -185,7 +185,7 @@ Converts a reactive object to a plain object where each property of the resultin
   type ToRef = T extends Ref ? T : Ref<T>
   ```
 
-- **Example**
+- **Esempio**
 
   ```js
   const state = reactive({
@@ -195,13 +195,13 @@ Converts a reactive object to a plain object where each property of the resultin
 
   const stateAsRefs = toRefs(state)
   /*
-  Type of stateAsRefs: {
+  Tipo di stateAsRefs: {
     foo: Ref<number>,
     bar: Ref<number>
   }
   */
 
-  // The ref and the original property is "linked"
+  // Il ref e la proprietà originale sono "collegati"
   state.foo++
   console.log(stateAsRefs.foo.value) // 2
 
@@ -209,7 +209,7 @@ Converts a reactive object to a plain object where each property of the resultin
   console.log(state.foo) // 3
   ```
 
-  `toRefs` is useful when returning a reactive object from a composable function so that the consuming component can destructure/spread the returned object without losing reactivity:
+  `toRefs` è utile quando si restituisce un oggetto reattivo da una funzione componibile in modo che il componente consumatore possa decostruire/spargere l'oggetto restituito senza perdere la reattività:
 
   ```js
   function useFeatureX() {
@@ -218,23 +218,23 @@ Converts a reactive object to a plain object where each property of the resultin
       bar: 2
     })
 
-    // ...logic operating on state
+    // ...logica che opera sullo state
 
-    // convert to refs when returning
+    // converti in ref quando viene fatto il return
     return toRefs(state)
   }
 
-  // can destructure without losing reactivity
+  // può essere destrutturato senza perdere la reattività
   const { foo, bar } = useFeatureX()
   ```
 
-  `toRefs` will only generate refs for properties that are enumerable on the source object at call time. To create a ref for a property that may not exist yet, use [`toRef`](#toref) instead.
+  `toRefs` genererà refs solo per le proprietà che sono enumerabili sull'oggetto sorgente al momento della chiamata. Per creare un ref per una proprietà che potrebbe non ancora esistere, utilizzare [`toRef`](#toref) al suo posto.
 
 ## isProxy() {#isproxy}
 
-Checks if an object is a proxy created by [`reactive()`](./reactivity-core#reactive), [`readonly()`](./reactivity-core#readonly), [`shallowReactive()`](./reactivity-advanced#shallowreactive) or [`shallowReadonly()`](./reactivity-advanced#shallowreadonly).
+Verifica se un oggetto è un proxy creato da [`reactive()`](./reactivity-core#reactive), [`readonly()`](./reactivity-core#readonly), [`shallowReactive()`](./reactivity-advanced#shallowreactive) o [`shallowReadonly()`](./reactivity-advanced#shallowreadonly).
 
-- **Type**
+- **Tipo**
 
   ```ts
   function isProxy(value: unknown): boolean
@@ -242,9 +242,9 @@ Checks if an object is a proxy created by [`reactive()`](./reactivity-core#react
 
 ## isReactive() {#isreactive}
 
-Checks if an object is a proxy created by [`reactive()`](./reactivity-core#reactive) or [`shallowReactive()`](./reactivity-advanced#shallowreactive).
+Verifica se un oggetto è un proxy creato da [`reactive()`](./reactivity-core#reactive) o [`shallowReactive()`](./reactivity-advanced#shallowreactive).
 
-- **Type**
+- **Tipo**
 
   ```ts
   function isReactive(value: unknown): boolean
@@ -252,11 +252,11 @@ Checks if an object is a proxy created by [`reactive()`](./reactivity-core#react
 
 ## isReadonly() {#isreadonly}
 
-Checks whether the passed value is a readonly object. The properties of a readonly object can change, but they can't be assigned directly via the passed object.
+Verifica se il valore passato è un oggetto di sola lettura. Le proprietà di un oggetto di sola lettura possono cambiare, ma non possono essere assegnate direttamente tramite l'oggetto passato.
 
-The proxies created by [`readonly()`](./reactivity-core#readonly) and [`shallowReadonly()`](./reactivity-advanced#shallowreadonly) are both considered readonly, as is a [`computed()`](./reactivity-core#computed) ref without a `set` function.
+I proxy creati da [`readonly()`](./reactivity-core#readonly) e [`shallowReadonly()`](./reactivity-advanced#shallowreadonly) ono entrambi considerati di sola lettura, così come un ref [`computed()`](./reactivity-core#computed) ref senza la funzione `set`.
 
-- **Type**
+- **Tipo**
 
   ```ts
   function isReadonly(value: unknown): boolean

From 25e4a2b453c7cf43f666171d3f2b7f71fb1f9f29 Mon Sep 17 00:00:00 2001
From: Paolo Dadda <ilpaolino@gmail.com>
Date: Thu, 19 Oct 2023 00:18:12 +0200
Subject: [PATCH 5/5] docs: Reactivity API: Core

---
 src/api/reactivity-core.md | 224 +++++++++++++++++++------------------
 1 file changed, 113 insertions(+), 111 deletions(-)

diff --git a/src/api/reactivity-core.md b/src/api/reactivity-core.md
index ce671e1c..2919752f 100644
--- a/src/api/reactivity-core.md
+++ b/src/api/reactivity-core.md
@@ -1,17 +1,17 @@
 # Reactivity API: Core {#reactivity-api-core}
 
-:::info See also
-To better understand the Reactivity APIs, it is recommended to read the following chapters in the guide:
+:::info Vedi anche
+Per comprendere meglio le API di reattività, si consiglia di leggere i seguenti capitoli nella guida:
 
-- [Reactivity Fundamentals](/guide/essentials/reactivity-fundamentals) (with the API preference set to Composition API)
-- [Reactivity in Depth](/guide/extras/reactivity-in-depth)
+- [Fondamenti della reattività](/guide/essentials/reactivity-fundamentals) (with the API preference set to Composition API)
+- [Reattività approfondita](/guide/extras/reactivity-in-depth)
   :::
 
 ## ref() {#ref}
 
-Takes an inner value and returns a reactive and mutable ref object, which has a single property `.value` that points to the inner value.
+Prende un valore interno e restituisce un oggetto ref reattivo e modificabile, che ha una singola proprietà `.value` che punta al suo valore interno.
 
-- **Type**
+- **Tipo**
 
   ```ts
   function ref<T>(value: T): Ref<UnwrapRef<T>>
@@ -21,15 +21,15 @@ Takes an inner value and returns a reactive and mutable ref object, which has a
   }
   ```
 
-- **Details**
+- **Dettagli**
 
-  The ref object is mutable - i.e. you can assign new values to `.value`. It is also reactive - i.e. any read operations to `.value` are tracked, and write operations will trigger associated effects.
+L'oggetto ref è mutevole, ovvero è possibile assegnare nuovi valori a `.value`. È anche reattivo, cioè tutte le operazioni di lettura su `.value` sono tracciate, e le operazioni di scrittura scateneranno gli effetti associati.
 
-  If an object is assigned as a ref's value, the object is made deeply reactive with [reactive()](#reactive). This also means if the object contains nested refs, they will be deeply unwrapped.
+Se un oggetto viene assegnato come valore di un ref, l'oggetto viene reso profondamente reattivo con [reactive()](#reactive). Ciò significa anche che se l'oggetto contiene ref nidificati, saranno estratti profondamente.
 
-  To avoid the deep conversion, use [`shallowRef()`](./reactivity-advanced#shallowref) instead.
+Per evitare la conversione profonda, puoi usare [`shallowRef()`](./reactivity-advanced#shallowref).
 
-- **Example**
+- **Esempio**
 
   ```js
   const count = ref(0)
@@ -39,25 +39,25 @@ Takes an inner value and returns a reactive and mutable ref object, which has a
   console.log(count.value) // 1
   ```
 
-- **See also**
-  - [Guide - Reactivity Fundamentals with `ref()`](/guide/essentials/reactivity-fundamentals#ref)
-  - [Guide - Typing `ref()`](/guide/typescript/composition-api#typing-ref) <sup class="vt-badge ts" />
+- **Vedi anche**
+  - [Guide - Fondamenti della reattività con `ref()`](/guide/essentials/reactivity-fundamentals#ref)
+  - [Guide - Tipizzazione `ref()`](/guide/typescript/composition-api#typing-ref) <sup class="vt-badge ts" />
 
 ## computed() {#computed}
 
-Takes a getter function and returns a readonly reactive [ref](#ref) object for the returned value from the getter. It can also take an object with `get` and `set` functions to create a writable ref object.
+Prende una funzione getter e restituisce un oggetto ref reattivo in sola lettura per il valore restituito dalla funzione getter. Può anche accettare un oggetto con funzioni `get` e `set` per creare un oggetto ref modificabile.
 
-- **Type**
+- **Tipo**
 
   ```ts
-  // read-only
+  // sola lettura
   function computed<T>(
     getter: () => T,
-    // see "Computed Debugging" link below
+    // vedi "Computed Debugging" link sotto
     debuggerOptions?: DebuggerOptions
   ): Readonly<Ref<Readonly<T>>>
 
-  // writable
+  // modificabile
   function computed<T>(
     options: {
       get: () => T
@@ -67,9 +67,9 @@ Takes a getter function and returns a readonly reactive [ref](#ref) object for t
   ): Ref<T>
   ```
 
-- **Example**
+- **Esempio**
 
-  Creating a readonly computed ref:
+  Creazione di un ref reattivo in sola lettura:
 
   ```js
   const count = ref(1)
@@ -77,10 +77,10 @@ Takes a getter function and returns a readonly reactive [ref](#ref) object for t
 
   console.log(plusOne.value) // 2
 
-  plusOne.value++ // error
+  plusOne.value++ // errore
   ```
 
-  Creating a writable computed ref:
+  Creazione di un ref modificabile:
 
   ```js
   const count = ref(1)
@@ -108,73 +108,75 @@ Takes a getter function and returns a readonly reactive [ref](#ref) object for t
   })
   ```
 
-- **See also**
-  - [Guide - Computed Properties](/guide/essentials/computed)
-  - [Guide - Computed Debugging](/guide/extras/reactivity-in-depth#computed-debugging)
-  - [Guide - Typing `computed()`](/guide/typescript/composition-api#typing-computed) <sup class="vt-badge ts" />
+- **Vedi anche**
+  - [Guide - Proprietà delle Computed](/guide/essentials/computed)
+  - [Guide - Debug delle Computed](/guide/extras/reactivity-in-depth#computed-debugging)
+  - [Guide - Tipizzazione `computed()`](/guide/typescript/composition-api#typing-computed) <sup class="vt-badge ts" />
 
 ## reactive() {#reactive}
 
-Returns a reactive proxy of the object.
+Ritorna un proxy reattivo dell'oggetto.
 
-- **Type**
+- **Tipo**
 
   ```ts
   function reactive<T extends object>(target: T): UnwrapNestedRefs<T>
   ```
 
-- **Details**
+- **Dettagli**
 
-  The reactive conversion is "deep": it affects all nested properties. A reactive object also deeply unwraps any properties that are [refs](#ref) while maintaining reactivity.
+La conversione reattiva è "profonda": influisce su tutte le proprietà nidificate. Un oggetto reattivo estrae 
 
-  It should also be noted that there is no ref unwrapping performed when the ref is accessed as an element of a reactive array or a native collection type like `Map`.
+ profondamente anche tutte le proprietà che sono [ref](#ref), mantenendone al contempo la reattività.
 
-  To avoid the deep conversion and only retain reactivity at the root level, use [shallowReactive()](./reactivity-advanced#shallowreactive) instead.
+Va notato che non viene eseguito l'estrazione di ref quando il ref è acceduto come elemento di un array reattivo o di un tipo di collezione nativo come il `Map`.
 
-  The returned object and its nested objects are wrapped with [ES Proxy](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy) and **not** equal to the original objects. It is recommended to work exclusively with the reactive proxy and avoid relying on the original object.
+Per evitare la conversione profonda e mantenere la reattività solo al livello root, usare [shallowReactive()](./reactivity-advanced#shallowreactive).
 
-- **Example**
+L'oggetto restituito e i suoi oggetti nidificati sono racchiusi con [ES Proxy](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy) e **non** sono uguali agli oggetti originali. Si consiglia di lavorare esclusivamente con il proxy reattivo ed evitar di fare affidamento sull'oggetto originale.
 
-  Creating a reactive object:
+- **Esempio**
+
+  Creazione di un oggetto reattivo:
 
   ```js
   const obj = reactive({ count: 0 })
   obj.count++
   ```
 
-  Ref unwrapping:
+  Estrazione del Ref:
 
   ```ts
   const count = ref(1)
   const obj = reactive({ count })
 
-  // ref will be unwrapped
+  // il ref verrà estratto
   console.log(obj.count === count.value) // true
 
-  // it will update `obj.count`
+  // sarà aggiornato `obj.count`
   count.value++
   console.log(count.value) // 2
   console.log(obj.count) // 2
 
-  // it will also update `count` ref
+  // sarà aggiornato anche il ref `count`
   obj.count++
   console.log(obj.count) // 3
   console.log(count.value) // 3
   ```
 
-  Note that refs are **not** unwrapped when accessed as array or collection elements:
+  Nota che i ref **non** vengono estratti quando vengono acceduti come elementi di un array o di una collezione:
 
   ```js
   const books = reactive([ref('Vue 3 Guide')])
-  // need .value here
+  // serve .value qui
   console.log(books[0].value)
 
   const map = reactive(new Map([['count', ref(0)]]))
-  // need .value here
+  // serve .value qui
   console.log(map.get('count').value)
   ```
 
-  When assigning a [ref](#ref) to a `reactive` property, that ref will also be automatically unwrapped:
+Quando si assegna un [ref](#ref) a una proprietà `reactive`, tale ref verrà anche automaticamente estratto:
 
   ```ts
   const count = ref(1)
@@ -186,15 +188,15 @@ Returns a reactive proxy of the object.
   console.log(obj.count === count.value) // true
   ```
 
-- **See also**
-  - [Guide - Reactivity Fundamentals](/guide/essentials/reactivity-fundamentals)
-  - [Guide - Typing `reactive()`](/guide/typescript/composition-api#typing-reactive) <sup class="vt-badge ts" />
+- **Vedi anche**
+  - [Guide - Fondamenti della reattività](/guide/essentials/reactivity-fundamentals)
+  - [Guide - Tipizzazione `reactive()`](/guide/typescript/composition-api#typing-reactive) <sup class="vt-badge ts" />
 
 ## readonly() {#readonly}
 
-Takes an object (reactive or plain) or a [ref](#ref) and returns a readonly proxy to the original.
+Prende un oggetto (reattivo o normale) o un [ref](#ref) e restituisce un proxy di sola lettura all'originale.
 
-- **Type**
+- **Tipo**
 
   ```ts
   function readonly<T extends object>(
@@ -202,13 +204,13 @@ Takes an object (reactive or plain) or a [ref](#ref) and returns a readonly prox
   ): DeepReadonly<UnwrapNestedRefs<T>>
   ```
 
-- **Details**
+- **Dettagli**
 
-  A readonly proxy is deep: any nested property accessed will be readonly as well. It also has the same ref-unwrapping behavior as `reactive()`, except the unwrapped values will also be made readonly.
+ Un proxy di sola lettura profondo: ogni proprietà nidificata a cui si accede sarà anch'essa di sola lettura. Ha anche lo stesso comportamento di estrazione dei ref di `reactive()`, tranne che i valori estratti saranno anch'essi resi di sola lettura.
 
-  To avoid the deep conversion, use [shallowReadonly()](./reactivity-advanced#shallowreadonly) instead.
+Per evitare la conversione profonda, usare [shallowReadonly()](./reactivity-advanced#shallowreadonly).
 
-- **Example**
+- **Esempio**
 
   ```js
   const original = reactive({ count: 0 })
@@ -216,22 +218,22 @@ Takes an object (reactive or plain) or a [ref](#ref) and returns a readonly prox
   const copy = readonly(original)
 
   watchEffect(() => {
-    // works for reactivity tracking
+    // funziona per il tracciamento della reattività
     console.log(copy.count)
   })
 
-  // mutating original will trigger watchers relying on the copy
+  // cambiare original attiverà i watcher che dipendono dalla copia
   original.count++
 
-  // mutating the copy will fail and result in a warning
+  // cambiare copy fallirà e produrrà un warning
   copy.count++ // warning!
   ```
 
 ## watchEffect() {#watcheffect}
 
-Runs a function immediately while reactively tracking its dependencies and re-runs it whenever the dependencies are changed.
+Esegue immediatamente una funzione mentre traccia reattivamente le sue dipendenze e la ri-esegue ogni volta che le dipendenze vengono modificate.
 
-- **Type**
+- **Tipo**
 
   ```ts
   function watchEffect(
@@ -250,17 +252,17 @@ Runs a function immediately while reactively tracking its dependencies and re-ru
   type StopHandle = () => void
   ```
 
-- **Details**
+- **Dettagli**
 
-  The first argument is the effect function to be run. The effect function receives a function that can be used to register a cleanup callback. The cleanup callback will be called right before the next time the effect is re-run, and can be used to clean up invalidated side effects, e.g. a pending async request (see example below).
+  Il primo argomento è la funzione d'effetto (effect) da eseguire. La funzione d'effetto riceve una funzione che può essere utilizzata per registrare una callback di pulizia (cleanup). La cleanup sarà chiamata esattamente prima della successiva esecuzione dell'effetto, e può essere utilizzata per ripulire effetti collaterali non validi, ad esempio una richiesta asincrona in sospeso (vedi esempio sotto).
 
-  The second argument is an optional options object that can be used to adjust the effect's flush timing or to debug the effect's dependencies.
+  Il secondo argomento è un oggetto opzionale di opzioni che può essere utilizzato per regolare il timing di esecuzione dell'effetto o per eseguire il debug delle dipendenze dell'effetto.
 
-  By default, watchers will run just prior to component rendering. Setting `flush: 'post'` will defer the watcher until after component rendering. See [Callback Flush Timing](/guide/essentials/watchers#callback-flush-timing) for more information. In rare cases, it might be necessary to trigger a watcher immediately when a reactive dependency changes, e.g. to invalidate a cache. This can be achieved using `flush: 'sync'`. However, this setting should be used with caution, as it can lead to problems with performance and data consistency if multiple properties are being updated at the same time.
+  Per impostazione predefinita, i watcher vengono eseguiti poco prima del rendering del componente. Impostare `flush: 'post'` ritarderà l'esecuzione del watcher dopo il rendering del componente. Vedere [Callback Flush Timing](/guide/essentials/watchers#callback-flush-timing) per ulteriori informazioni. In casi rari, potrebbe essere necessario attivare immediatamente un watcher quando una dipendenza reattiva cambia, ad esempio per invalidare una cache. Si può fare usando `flush: 'sync'`. Questa impostazione, tuttavia, dovrebbe essere utilizzata con cautela, poiché può causare problemi di prestazioni e coerenza dei dati se più proprietà vengono aggiornate contemporaneamente.
 
-  The return value is a handle function that can be called to stop the effect from running again.
+  Il valore restituito è una funzione di gestione che può essere chiamata per interrompere l'esecuzione dell'effetto.
 
-- **Example**
+- **Esempio**
 
   ```js
   const count = ref(0)
@@ -272,29 +274,29 @@ Runs a function immediately while reactively tracking its dependencies and re-ru
   // -> logs 1
   ```
 
-  Side effect cleanup:
+  Pulizia degli effetti collaterali:
 
   ```js
   watchEffect(async (onCleanup) => {
     const { response, cancel } = doAsyncWork(id.value)
-    // `cancel` will be called if `id` changes
-    // so that previous pending request will be cancelled
-    // if not yet completed
+    // `cancel` verrà chiamato se `id` cambia
+    // quindi la richiesta in sospeso precedente verrà annullata
+    // se non è ancora stata completata
     onCleanup(cancel)
     data.value = await response
   })
   ```
 
-  Stopping the watcher:
+  Fermare il watcher:
 
   ```js
   const stop = watchEffect(() => {})
 
-  // when the watcher is no longer needed:
+  // quando il watcher non è più necessario:
   stop()
   ```
 
-  Options:
+  Opzioni:
 
   ```js
   watchEffect(() => {}, {
@@ -308,33 +310,33 @@ Runs a function immediately while reactively tracking its dependencies and re-ru
   })
   ```
 
-- **See also**
+- **Vedi anche**
   - [Guide - Watchers](/guide/essentials/watchers#watcheffect)
-  - [Guide - Watcher Debugging](/guide/extras/reactivity-in-depth#watcher-debugging)
+  - [Guide - Debug dei Watcher](/guide/extras/reactivity-in-depth#watcher-debugging)
 
 ## watchPostEffect() {#watchposteffect}
 
-Alias of [`watchEffect()`](#watcheffect) with `flush: 'post'` option.
+Alias di [`watchEffect()`](#watcheffect) con l'opzione `flush: 'post'`.
 
 ## watchSyncEffect() {#watchsynceffect}
 
-Alias of [`watchEffect()`](#watcheffect) with `flush: 'sync'` option.
+Alias di [`watchEffect()`](#watcheffect) con l'opzione `flush: 'sync'`.
 
 ## watch() {#watch}
 
-Watches one or more reactive data sources and invokes a callback function when the sources change.
+Osserva una o più fonti di dati reattive e invoca una funzione di callback quando le fonti cambiano.
 
-- **Type**
+- **Tipo**
 
   ```ts
-  // watching single source
+  // watch sulla singola source
   function watch<T>(
     source: WatchSource<T>,
     callback: WatchCallback<T>,
     options?: WatchOptions
   ): StopHandle
 
-  // watching multiple sources
+  // watch su più sources
   function watch<T>(
     sources: WatchSource<T>[],
     callback: WatchCallback<T[]>,
@@ -352,7 +354,7 @@ Watches one or more reactive data sources and invokes a callback function when t
     | (() => T) // getter
     | T extends object
     ? T
-    : never // reactive object
+    : never // oggetto reattivo
 
   interface WatchOptions extends WatchEffectOptions {
     immediate?: boolean // default: false
@@ -363,39 +365,39 @@ Watches one or more reactive data sources and invokes a callback function when t
   }
   ```
 
-  > Types are simplified for readability.
+  > I tipi sono semplificati per leggibilità.
 
-- **Details**
+- **Dettagli**
 
-  `watch()` is lazy by default - i.e. the callback is only called when the watched source has changed.
+`watch()` è lazy di default, ovvero la funzione di callback viene chiamata solo quando la source osservata cambia.
 
-  The first argument is the watcher's **source**. The source can be one of the following:
+  Il primo argomento è la **source** del watcher. La source può essere una delle seguenti:
 
-  - A getter function that returns a value
-  - A ref
-  - A reactive object
-  - ...or an array of the above.
+  - Una funzione getter che restituisce un valore
+  - Una ref
+  - Un oggetto reattivo
+  - ...o un array dei punti precedenti.
 
-  The second argument is the callback that will be called when the source changes. The callback receives three arguments: the new value, the old value, and a function for registering a side effect cleanup callback. The cleanup callback will be called right before the next time the effect is re-run, and can be used to clean up invalidated side effects, e.g. a pending async request.
+  Il secondo argomento è la funzione di callback che verrà chiamata quando la source cambia. La callback riceve tre argomenti: il nuovo valore, il vecchio valore e una funzione per registrare una callback di pulizia degli effetti collaterali. La callback di pulizia sarà chiamata proprio prima della successiva esecuzione dell'effetto e può essere utilizzata per pulire effetti collaterali non validi, ad esempio una richiesta asincrona in sospeso.
 
-  When watching multiple sources, the callback receives two arrays containing new / old values corresponding to the source array.
+  Quando si osservano più sources, la callback riceve due array contenenti i valori nuovi/vecchi corrispondenti all'array di sources.
 
-  The third optional argument is an options object that supports the following options:
+  Il terzo argomento opzionale è un oggetto di opzioni che supporta le seguenti opzioni:
 
-  - **`immediate`**: trigger the callback immediately on watcher creation. Old value will be `undefined` on the first call.
-  - **`deep`**: force deep traversal of the source if it is an object, so that the callback fires on deep mutations. See [Deep Watchers](/guide/essentials/watchers#deep-watchers).
-  - **`flush`**: adjust the callback's flush timing. See [Callback Flush Timing](/guide/essentials/watchers#callback-flush-timing) and [`watchEffect()`](/api/reactivity-core#watcheffect).
-  - **`onTrack / onTrigger`**: debug the watcher's dependencies. See [Watcher Debugging](/guide/extras/reactivity-in-depth#watcher-debugging).
+  - **`immediate`**: attiva immediatamente la callback alla creazione del watcher. Il vecchio valore sarà `undefined` alla prima chiamata.
+  - **`deep`**: forza la lettura profonda delle proprietà della source se è un oggetto, in modo che la callback si attivi durante le mutazioni profonde. Vedi [Deep Watchers](/guide/essentials/watchers#deep-watchers).
+  - **`flush`**: regola il timing di esecuzione della callback. Vedi [Callback Flush Timing](/guide/essentials/watchers#callback-flush-timing) e [`watchEffect()`](/api/reactivity-core#watcheffect).
+  - **`onTrack / onTrigger`**: esegue il debug delle dipendenze del watcher. Vedi [Watcher Debugging](/guide/extras/reactivity-in-depth#watcher-debugging).
 
-  Compared to [`watchEffect()`](#watcheffect), `watch()` allows us to:
+  Rispetto a [`watchEffect()`](#watcheffect), `watch()` ci consente di:
 
-  - Perform the side effect lazily;
-  - Be more specific about what state should trigger the watcher to re-run;
-  - Access both the previous and current value of the watched state.
+  - Eseguire l'effetto collaterale in modo pigro;
+  - Essere più specifici su quale stato dovrebbe attivare nuovamente il watcher;
+  - Accedere sia al valore precedente che a quello corrente dello stato osservato.
 
-- **Example**
+- **Esempio**
 
-  Watching a getter:
+  Fare il watch di un getter:
 
   ```js
   const state = reactive({ count: 0 })
@@ -407,7 +409,7 @@ Watches one or more reactive data sources and invokes a callback function when t
   )
   ```
 
-  Watching a ref:
+  Fare il watch di una ref:
 
   ```js
   const count = ref(0)
@@ -416,7 +418,7 @@ Watches one or more reactive data sources and invokes a callback function when t
   })
   ```
 
-  When watching multiple sources, the callback receives arrays containing new / old values corresponding to the source array:
+  Quando si osservano più sources, la funzione di callback riceve array contenenti i valori nuovi/vecchi corrispondenti all'array di sources:
 
   ```js
   watch([fooRef, barRef], ([foo, bar], [prevFoo, prevBar]) => {
@@ -424,7 +426,7 @@ Watches one or more reactive data sources and invokes a callback function when t
   })
   ```
 
-  When using a getter source, the watcher only fires if the getter's return value has changed. If you want the callback to fire even on deep mutations, you need to explicitly force the watcher into deep mode with `{ deep: true }`. Note in deep mode, the new value and the old will be the same object if the callback was triggered by a deep mutation:
+  Quando si utilizza una source getter, il watcher si attiva solo se il valore restituito dal getter è cambiato. Se si desidera che la funzione di callback si attivi anche su mutazioni profonde, è necessario forzare esplicitamente il watcher in modalità profonda con `{ deep: true }`. Nota che in modalità profonda, il nuovo e il vecchio valore saranno lo stesso oggetto se la callback è stata attivata da una mutazione profonda:
 
   ```js
   const state = reactive({ count: 0 })
@@ -437,16 +439,16 @@ Watches one or more reactive data sources and invokes a callback function when t
   )
   ```
 
-  When directly watching a reactive object, the watcher is automatically in deep mode:
+  Quando si osserva direttamente un oggetto reattivo, il watcher è automaticamente in modalità profonda:
 
   ```js
   const state = reactive({ count: 0 })
   watch(state, () => {
-    /* triggers on deep mutation to state */
+    /* attivato da una mutazione profonda di state */
   })
   ```
 
-  `watch()` shares the same flush timing and debugging options with [`watchEffect()`](#watcheffect):
+  `watch()` condivide lo stesso timing di esecuzione e le opzioni di debug con [`watchEffect()`](#watcheffect):
 
   ```js
   watch(source, callback, {
@@ -460,7 +462,7 @@ Watches one or more reactive data sources and invokes a callback function when t
   })
   ```
 
-  Stopping the watcher:
+  Ferma il watcher:
 
   ```js
   const stop = watch(source, callback)
@@ -469,7 +471,7 @@ Watches one or more reactive data sources and invokes a callback function when t
   stop()
   ```
 
-  Side effect cleanup:
+  Pulizia degli effetti collaterali:
 
   ```js
   watch(id, async (newId, oldId, onCleanup) => {
@@ -481,7 +483,7 @@ Watches one or more reactive data sources and invokes a callback function when t
   })
   ```
 
-- **See also**
+- **Vedi anche**
 
   - [Guide - Watchers](/guide/essentials/watchers)
-  - [Guide - Watcher Debugging](/guide/extras/reactivity-in-depth#watcher-debugging)
+  - [Guide - Debug dei Watcher](/guide/extras/reactivity-in-depth#watcher-debugging)