{}, url: document.location.pathname});
function navigate(url) {
startTransition(() => {
- // Transition type for the cause "nav forward"
+ // Transition type per la causa "nav forward"
addTransitionType('nav-forward');
go(url);
});
}
function navigateBack(url) {
startTransition(() => {
- // Transition type for the cause "nav backward"
+ // Transition type per la causa "nav backward"
addTransitionType('nav-back');
go(url);
});
@@ -13416,13 +13423,13 @@ export function Router({ children }) {
useEffect(() => {
function handlePopState() {
- // This should not animate because restoration has to be synchronous.
- // Even though it's a transition.
+ // Questo non dovrebbe animarsi perché il ripristino deve essere sincrono.
+ // Anche se è una transizione.
startTransition(() => {
setRouterState({
url: document.location.pathname + document.location.search,
pendingNav() {
- // Noop. URL has already updated.
+ // Noop. L'URL è già stato aggiornato.
},
});
});
@@ -14034,7 +14041,7 @@ ul {
```css src/animations.css
-/* No additional animations needed */
+/* Nessuna animazione aggiuntiva necessaria */
@@ -14044,14 +14051,14 @@ ul {
-/* Previously defined animations below */
+/* Animazioni definite in precedenza sotto */
-/* Slide animations for Suspense the fallback down */
+/* Animazioni slide per far scorrere il fallback Suspense verso il basso */
::view-transition-old(.slide-down) {
animation: 150ms ease-out both fade-out, 150ms ease-out both slide-down;
}
@@ -14060,32 +14067,32 @@ ul {
animation: 210ms ease-in 150ms both fade-in, 400ms ease-in both slide-up;
}
-/* Animations for view transition classed added by transition type */
+/* Animazioni per le view transition class aggiunte dal transition type */
::view-transition-old(.slide-forward) {
- /* when sliding forward, the "old" page should slide out to left. */
+ /* quando si scorre in avanti, la pagina "old" dovrebbe uscire verso sinistra. */
animation: 150ms cubic-bezier(0.4, 0, 1, 1) both fade-out,
400ms cubic-bezier(0.4, 0, 0.2, 1) both slide-to-left;
}
::view-transition-new(.slide-forward) {
- /* when sliding forward, the "new" page should slide in from right. */
+ /* quando si scorre in avanti, la pagina "new" dovrebbe entrare da destra. */
animation: 210ms cubic-bezier(0, 0, 0.2, 1) 150ms both fade-in,
400ms cubic-bezier(0.4, 0, 0.2, 1) both slide-from-right;
}
::view-transition-old(.slide-back) {
- /* when sliding back, the "old" page should slide out to right. */
+ /* quando si scorre indietro, la pagina "old" dovrebbe uscire verso destra. */
animation: 150ms cubic-bezier(0.4, 0, 1, 1) both fade-out,
400ms cubic-bezier(0.4, 0, 0.2, 1) both slide-to-right;
}
::view-transition-new(.slide-back) {
- /* when sliding back, the "new" page should slide in from left. */
+ /* quando si scorre indietro, la pagina "new" dovrebbe entrare da sinistra. */
animation: 210ms cubic-bezier(0, 0, 0.2, 1) 150ms both fade-in,
400ms cubic-bezier(0.4, 0, 0.2, 1) both slide-from-left;
}
-/* Keyframes to support our animations above. */
+/* Keyframe per supportare le nostre animazioni sopra. */
@keyframes slide-up {
from {
transform: translateY(10px);
@@ -14193,45 +14200,45 @@ root.render(
-### Server-Side Rendering with Activity {/*server-side-rendering-with-activity*/}
+### Server-Side Rendering con Activity {/*server-side-rendering-with-activity*/}
-When using Activity on a page that uses server-side rendering (SSR), there are additional optimizations.
+Quando usi Activity su una pagina che usa server-side rendering (SSR), ci sono ottimizzazioni aggiuntive.
-If part of the page is rendered with `mode="hidden"`, then it will not be included in the SSR response. Instead, React will schedule a client render for the content inside Activity while the rest of the page hydrates, prioritizing the visible content on screen.
+Se parte della pagina viene renderizzata con `mode="hidden"`, non sarà inclusa nella risposta SSR. Invece, React programmerà una renderizzazione client per il contenuto dentro Activity mentre il resto della pagina si idrata, dando priorità al contenuto visibile sullo schermo.
-For parts of the UI rendered with `mode="visible"`, React will de-prioritize hydration of content within Activity, similar to how Suspense content is hydrated at a lower priority. If the user interacts with the page, we'll prioritize hydration within the boundary if needed.
+Per le parti dell'UI renderizzate con `mode="visible"`, React deprioritizzerà l'hydration del contenuto dentro Activity, simile a come il contenuto Suspense viene idratato con priorità più bassa. Se l'utente interagisce con la pagina, daremo priorità all'hydration dentro il boundary se necessario.
-These are advanced use cases, but they show the additional benefits considered with Activity.
+Sono casi d'uso avanzati, ma mostrano i benefici aggiuntivi considerati con Activity.
-### Future modes for Activity {/*future-modes-for-activity*/}
+### Modalità future per Activity {/*future-modes-for-activity*/}
-In the future, we may add more modes to Activity.
+In futuro, potremmo aggiungere altre modalità ad Activity.
-For example, a common use case is rendering a modal, where the previous "inactive" page is visible behind the "active" modal view. The "hidden" mode does not work for this use case because it's not visible and not included in SSR.
+Per esempio, un caso d'uso comune è renderizzare un modal, dove la pagina "inattiva" precedente è visibile dietro la vista modal "attiva". La modalità "hidden" non funziona per questo caso d'uso perché non è visibile e non è inclusa nell'SSR.
-Instead, we're considering a new mode that would keep the content visible—and included in SSR—but keep it unmounted and de-prioritize updates. This mode may also need to "pause" DOM updates, since it can be distracting to see backgrounded content updating while a modal is open.
+Invece, stiamo considerando una nuova modalità che manterrebbe il contenuto visibile—e incluso nell'SSR—ma lo terrebbe smontato e deprioritizzerebbe gli aggiornamenti. Questa modalità potrebbe anche dover "mettere in pausa" gli aggiornamenti DOM, poiché può distrarre vedere contenuto in background aggiornarsi mentre un modal è aperto.
-Another mode we're considering for Activity is the ability to automatically destroy state for hidden Activities if there is too much memory being used. Since the component is already unmounted, it may be preferable to destroy state for the least recently used hidden parts of the app rather than consume too many resources.
+Un'altra modalità che stiamo considerando per Activity è la possibilità di distruggere automaticamente lo state per le Activity hidden se viene usata troppa memoria. Poiché il componente è già smontato, potrebbe essere preferibile distruggere lo state per le parti hidden meno recentemente usate dell'app piuttosto che consumare troppe risorse.
-These are areas we're still exploring, and we'll share more as we make progress. For more information on what Activity includes today, [check out the docs](/reference/react/Activity).
+Sono aree che stiamo ancora esplorando e condivideremo di più man mano che progrediamo. Per maggiori informazioni su cosa include Activity oggi, [consulta la documentazione](/reference/react/Activity).
---
-# Features in development {/*features-in-development*/}
+# Funzionalità in sviluppo {/*features-in-development*/}
-We're also developing features to help solve the common problems below.
+Stiamo anche sviluppando funzionalità per aiutare a risolvere i problemi comuni sotto.
-As we iterate on possible solutions, you may see some potential APIs we're testing being shared based on the PRs we are landing. Please keep in mind that as we try different ideas, we often change or remove different solutions after trying them out.
+Mentre iteriamo sulle possibili soluzioni, potresti vedere alcune API potenziali che stiamo testando condivise in base alle PR che stiamo mergiando. Tieni presente che mentre proviamo idee diverse, spesso cambiamo o rimuoviamo soluzioni diverse dopo averle testate.
-When the solutions we're working on are shared too early, it can create churn and confusion in the community. To balance being transparent and limiting confusion, we're sharing the problems we're currently developing solutions for, without sharing a particular solution we have in mind.
+Quando le soluzioni su cui stiamo lavorando vengono condivise troppo presto, possono creare churn e confusione nella community. Per bilanciare trasparenza e limitare la confusione, condividiamo i problemi per cui stiamo attualmente sviluppando soluzioni, senza condividere una soluzione particolare che abbiamo in mente.
-As these features progress, we'll announce them on the blog with docs included so you can try them out.
+Man mano che queste funzionalità progrediscono, le annunceremo sul blog con documentazione inclusa così puoi provarle.
## React Performance Tracks {/*react-performance-tracks*/}
-We're working on a new set of custom tracks to performance profilers using browser APIs that [allow adding custom tracks](https://developer.chrome.com/docs/devtools/performance/extension) to provide more information about the performance of your React app.
+Stiamo lavorando a un nuovo set di track personalizzate per i profiler di performance usando API browser che [permettono di aggiungere track personalizzate](https://developer.chrome.com/docs/devtools/performance/extension) per fornire più informazioni sulla performance della tua app React.
-This feature is still in progress, so we're not ready to publish docs to fully release it as an experimental feature yet. You can get a sneak preview when using an experimental version of React, which will automatically add the performance tracks to profiles:
+Questa funzionalità è ancora in corso, quindi non siamo pronti a pubblicare documentazione per rilasciarla completamente come funzionalità sperimentale. Puoi avere un'anteprima usando una versione sperimentale di React, che aggiungerà automaticamente le performance track ai profili:
@@ -14244,53 +14251,53 @@ This feature is still in progress, so we're not ready to publish docs to fully r
-There are a few known issues we plan to address such as performance, and the scheduler track not always "connecting" work across Suspended trees, so it's not quite ready to try. We're also still collecting feedback from early adopters to improve the design and usability of the tracks.
+Ci sono alcuni problemi noti che prevediamo di affrontare come la performance, e la scheduler track che non sempre "collega" il lavoro tra alberi Suspended, quindi non è ancora pronta da provare. Stiamo anche raccogliendo feedback dagli early adopter per migliorare design e usabilità delle track.
-Once we solve those issues, we'll publish experimental docs and share that it's ready to try.
+Una volta risolti questi problemi, pubblicheremo documentazione sperimentale e condivideremo che è pronta da provare.
---
-## Automatic Effect Dependencies {/*automatic-effect-dependencies*/}
+## Dipendenze automatiche degli Effetti {/*automatic-effect-dependencies*/}
-When we released hooks, we had three motivations:
+Quando abbiamo rilasciato gli hooks, avevamo tre motivazioni:
-- **Sharing code between components**: hooks replaced patterns like render props and higher-order components to allow you to reuse stateful logic without changing your component hierarchy.
-- **Think in terms of function, not lifecycles**: hooks let you split one component into smaller functions based on what pieces are related (such as setting up a subscription or fetching data), rather than forcing a split based on lifecycle methods.
-- **Support ahead-of-time compilation**: hooks were designed to support ahead-of-time compilation with less pitfalls causing unintentional de-optimizations caused by lifecycle methods, and limitations of classes.
+- **Condividere codice tra componenti**: gli hooks hanno sostituito pattern come render props e higher-order component per permetterti di riutilizzare logica con state senza cambiare la gerarchia dei componenti.
+- **Pensare in termini di funzione, non di lifecycle**: gli hooks ti permettono di dividere un componente in funzioni più piccole in base a quali pezzi sono correlati (come impostare una sottoscrizione o recuperare dati), piuttosto che forzare una divisione basata sui metodi lifecycle.
+- **Supportare la compilazione ahead-of-time**: gli hooks sono stati progettati per supportare la compilazione ahead-of-time con meno insidie che causano de-ottimizzazioni involontarie causate dai metodi lifecycle e dalle limitazioni delle classi.
-Since their release, hooks have been successful at *sharing code between components*. Hooks are now the favored way to share logic between components, and there are less use cases for render props and higher order components. Hooks have also been successful at supporting features like Fast Refresh that were not possible with class components.
+Dal loro rilascio, gli hooks hanno avuto successo nel *condividere codice tra componenti*. Gli hooks sono ora il modo preferito per condividere logica tra componenti, e ci sono meno casi d'uso per render props e higher order component. Gli hooks hanno anche avuto successo nel supportare funzionalità come Fast Refresh che non erano possibili con i componenti classe.
-### Effects can be hard {/*effects-can-be-hard*/}
+### Gli Effetti possono essere difficili {/*effects-can-be-hard*/}
-Unfortunately, some hooks are still hard to think in terms of function instead of lifecycles. Effects specifically are still hard to understand and are the most common pain point we hear from developers. Last year, we spent a significant amount of time researching how Effects were used, and how those use cases could be simplified and easier to understand.
+Purtroppo, alcuni hooks sono ancora difficili da pensare in termini di funzione invece che di lifecycle. Gli Effetti in particolare sono ancora difficili da capire e sono il pain point più comune che sentiamo dagli sviluppatori. L'anno scorso, abbiamo dedicato molto tempo a ricercare come venivano usati gli Effetti e come quei casi d'uso potessero essere semplificati e resi più facili da capire.
-We found that often, the confusion is from using an Effect when you don't need to. The [You Might Not Need an Effect](/learn/you-might-not-need-an-effect) guide covers many cases for when Effects are not the right solution. However, even when an Effect is the right fit for a problem, Effects can still be harder to understand than class component lifecycles.
+Abbiamo scoperto che spesso la confusione deriva dall'usare un Effetto quando non ne hai bisogno. La guida [You Might Not Need an Effect](/learn/you-might-not-need-an-effect) copre molti casi in cui gli Effetti non sono la soluzione giusta. Tuttavia, anche quando un Effetto è adatto a un problema, gli Effetti possono essere ancora più difficili da capire rispetto ai lifecycle dei componenti classe.
-We believe one of the reasons for confusion is that developers to think of Effects from the _component's_ perspective (like a lifecycle), instead of the _Effects_ point of view (what the Effect does).
+Crediamo che una delle ragioni della confusione sia che gli sviluppatori pensano agli Effetti dalla prospettiva del _componente_ (come un lifecycle), invece che dal punto di vista degli _Effetti_ (cosa fa l'Effetto).
-Let's look at an example [from the docs](/learn/lifecycle-of-reactive-effects#thinking-from-the-effects-perspective):
+Diamo un'occhiata a un esempio [dalla documentazione](/learn/lifecycle-of-reactive-effects#thinking-from-the-effects-perspective):
```js
useEffect(() => {
- // Your Effect connected to the room specified with roomId...
+ // Il tuo Effetto si connette alla stanza specificata con roomId...
const connection = createConnection(serverUrl, roomId);
connection.connect();
return () => {
- // ...until it disconnected
+ // ...finché non si disconnette
connection.disconnect();
};
}, [roomId]);
```
-Many users would read this code as "on mount, connect to the roomId. whenever `roomId` changes, disconnect to the old room and re-create the connection". However, this is thinking from the component's lifecycle perspective, which means you will need to think of every component lifecycle state to write the Effect correctly. This can be difficult, so it's understandable that Effects seem harder than class lifecycles when using the component perspective.
+Molti utenti leggerebbero questo codice come "al mount, connettiti al roomId. ogni volta che `roomId` cambia, disconnettiti dalla vecchia stanza e ricrea la connessione". Tuttavia, questo è pensare dalla prospettiva del lifecycle del componente, il che significa che dovrai pensare a ogni fase del lifecycle del componente per scrivere l'Effetto correttamente. Può essere difficile, quindi è comprensibile che gli Effetti sembrino più difficili dei lifecycle di classe quando usi la prospettiva del componente.
-### Effects without dependencies {/*effects-without-dependencies*/}
+### Effetti senza dipendenze {/*effects-without-dependencies*/}
-Instead, it's better to think from the Effect's perspective. The Effect doesn't know about the component lifecycles. It only describes how to start synchronization and how to stop it. When users think of Effects in this way, their Effects tend to be easier to write, and more resilient to being started and stopped as many times as is needed.
+Invece, è meglio pensare dalla prospettiva dell'Effetto. L'Effetto non conosce i lifecycle del componente. Descrive solo come avviare la sincronizzazione e come fermarla. Quando gli utenti pensano agli Effetti in questo modo, i loro Effetti tendono ad essere più facili da scrivere e più resilienti ad essere avviati e fermati quante volte serve.
-We spent some time researching why Effects are thought of from the component perspective, and we think one of the reasons is the dependency array. Since you have to write it, it's right there and in your face reminding you of what you're "reacting" to and baiting you into the mental model of 'do this when these values change'.
+Abbiamo dedicato del tempo a ricercare perché gli Effetti vengono pensati dalla prospettiva del componente, e pensiamo che una delle ragioni sia l'array di dipendenze. Poiché devi scriverlo, è lì davanti a te ricordandoti a cosa stai "reagendo" e spingendoti verso il modello mentale di 'fai questo quando questi valori cambiano'.
-When we released hooks, we knew we could make them easier to use with ahead-of-time compilation. With the React Compiler, you're now able to avoid writing `useCallback` and `useMemo` yourself in most cases. For Effects, the compiler can insert the dependencies for you:
+Quando abbiamo rilasciato gli hooks, sapevamo di poterli rendere più facili da usare con la compilazione ahead-of-time. Con React Compiler, ora puoi evitare di scrivere `useCallback` e `useMemo` da solo nella maggior parte dei casi. Per gli Effetti, il compiler può inserire le dipendenze per te:
```js
useEffect(() => {
@@ -14299,67 +14306,67 @@ useEffect(() => {
return () => {
connection.disconnect();
};
-}); // compiler inserted dependencies.
+}); // dipendenze inserite dal compiler.
```
-With this code, the React Compiler can infer the dependencies for you and insert them automatically so you don't need to see or write them. With features like [the IDE extension](#compiler-ide-extension) and [`useEffectEvent`](/reference/react/useEffectEvent), we can provide a CodeLens to show you what the Compiler inserted for times you need to debug, or to optimize by removing a dependency. This helps reinforce the correct mental model for writing Effects, which can run at any time to synchronize your component or hook's state with something else.
+Con questo codice, React Compiler può inferire le dipendenze per te e inserirle automaticamente così non devi vederle o scriverle. Con funzionalità come [l'estensione IDE](#compiler-ide-extension) e [`useEffectEvent`](/reference/react/useEffectEvent), possiamo fornire un CodeLens per mostrarti cosa ha inserito il Compiler quando devi fare debug, o per ottimizzare rimuovendo una dipendenza. Questo aiuta a rafforzare il modello mentale corretto per scrivere Effetti, che possono essere eseguiti in qualsiasi momento per sincronizzare lo state del componente o dell'hook con qualcos'altro.
-Our hope is that automatically inserting dependencies is not only easier to write, but that it also makes them easier to understand by forcing you to think in terms of what the Effect does, and not in component lifecycles.
+La nostra speranza è che inserire automaticamente le dipendenze non sia solo più facile da scrivere, ma che renda anche gli Effetti più facili da capire costringendoti a pensare in termini di cosa fa l'Effetto, e non in lifecycle del componente.
---
## Compiler IDE Extension {/*compiler-ide-extension*/}
-Later in 2025 [we shared](/blog/2025/10/07/react-compiler-1) the first stable release of React Compiler, and we're continuing to invest in shipping more improvements.
+Più avanti nel 2025 [abbiamo condiviso](/blog/2025/10/07/react-compiler-1) il primo rilascio stabile di React Compiler, e continuiamo a investire nel rilasciare altri miglioramenti.
-We've also begun exploring ways to use the React Compiler to provide information that can improve understanding and debugging your code. One idea we've started exploring is a new experimental LSP-based React IDE extension powered by React Compiler, similar to the extension used in [Lauren Tan's React Conf talk](https://conf2024.react.dev/talks/5).
+Abbiamo anche iniziato a esplorare modi per usare React Compiler per fornire informazioni che possono migliorare la comprensione e il debug del tuo codice. Un'idea che abbiamo iniziato a esplorare è una nuova estensione IDE React sperimentale basata su LSP alimentata da React Compiler, simile all'estensione usata nel [talk di Lauren Tan a React Conf](https://conf2024.react.dev/talks/5).
-Our idea is that we can use the compiler's static analysis to provide more information, suggestions, and optimization opportunities directly in your IDE. For example, we can provide diagnostics for code breaking the Rules of React, hovers to show if components and hooks were optimized by the compiler, or a CodeLens to see [automatically inserted Effect dependencies](#automatic-effect-dependencies).
+La nostra idea è che possiamo usare l'analisi statica del compiler per fornire più informazioni, suggerimenti e opportunità di ottimizzazione direttamente nel tuo IDE. Per esempio, possiamo fornire diagnostiche per codice che viola le Rules of React, hover per mostrare se componenti e hooks sono stati ottimizzati dal compiler, o un CodeLens per vedere le [dipendenze degli Effetti inserite automaticamente](#automatic-effect-dependencies).
-The IDE extension is still an early exploration, but we'll share our progress in future updates.
+L'estensione IDE è ancora un'esplorazione iniziale, ma condivideremo i progressi negli aggiornamenti futuri.
---
## Fragment Refs {/*fragment-refs*/}
-Many DOM APIs like those for event management, positioning, and focus are difficult to compose when writing with React. This often leads developers to reach for Effects, managing multiple Refs, by using APIs like `findDOMNode` (removed in React 19).
+Molte API DOM come quelle per la gestione degli eventi, il posizionamento e il focus sono difficili da comporre quando scrivi con React. Questo spesso porta gli sviluppatori a usare Effetti, gestendo più Ref, usando API come `findDOMNode` (rimossa in React 19).
-We are exploring adding refs to Fragments that would point to a group of DOM elements, rather than just a single element. Our hope is that this will simplify managing multiple children and make it easier to write composable React code when calling DOM APIs.
+Stiamo esplorando l'aggiunta di ref ai Fragment che puntino a un gruppo di elementi DOM, piuttosto che a un singolo elemento. La nostra speranza è che questo semplifichi la gestione di più figli e renda più facile scrivere codice React componibile quando chiami API DOM.
-Fragment refs are still being researched. We'll share more when we're closer to having the final API finished.
+I fragment ref sono ancora in fase di ricerca. Condivideremo di più quando saremo più vicini ad avere l'API finale completata.
---
-## Gesture Animations {/*gesture-animations*/}
+## Animazioni gesture {/*gesture-animations*/}
-We're also researching ways to enhance View Transitions to support gesture animations such as swiping to open a menu, or scroll through a photo carousel.
+Stiamo anche ricercando modi per migliorare le View Transitions per supportare animazioni gesture come scorrere per aprire un menu o scorrere un carosello di foto.
-Gestures present new challenges for a few reasons:
+I gesture presentano nuove sfide per alcuni motivi:
-- **Gestures are continuous**: as you swipe the animation is tied to your finger placement time, rather than triggering and running to completion.
-- **Gestures don't complete**: when you release your finger gesture animations can run to completion, or revert to their original state (like when you only partially open a menu) depending on how far you go.
-- **Gestures invert old and new**: while you're animating, you want the page you are animating from to stay "alive" and interactive. This inverts the browser View Transition model where the "old" state is a snapshot and the "new" state is the live DOM.
+- **I gesture sono continui**: mentre scorri, l'animazione è legata al posizionamento del dito nel tempo, piuttosto che attivarsi ed eseguirsi fino al completamento.
+- **I gesture non si completano**: quando rilasci il dito, le animazioni gesture possono eseguirsi fino al completamento o tornare al loro state originale (come quando apri solo parzialmente un menu) a seconda di quanto vai avanti.
+- **I gesture invertono old e new**: mentre animi, vuoi che la pagina da cui stai animando resti "viva" e interattiva. Questo inverte il modello View Transition del browser dove lo state "old" è un'istantanea e lo state "new" è il DOM live.
-We believe we’ve found an approach that works well and may introduce a new API for triggering gesture transitions. For now, we're focused on shipping `
`, and will revisit gestures afterward.
+Crediamo di aver trovato un approccio che funziona bene e potremmo introdurre una nuova API per attivare gesture transition. Per ora, siamo concentrati sul rilasciare ``, e torneremo sui gesture dopo.
---
## Concurrent Stores {/*concurrent-stores*/}
-When we released React 18 with concurrent rendering, we also released `useSyncExternalStore` so external store libraries that did not use React state or context could [support concurrent rendering](https://github.com/reactwg/react-18/discussions/70) by forcing a synchronous render when the store is updated.
+Quando abbiamo rilasciato React 18 con concurrent rendering, abbiamo anche rilasciato `useSyncExternalStore` così le librerie store esterne che non usavano React state o context potevano [supportare concurrent rendering](https://github.com/reactwg/react-18/discussions/70) forzando una renderizzazione sincrona quando lo store viene aggiornato.
-Using `useSyncExternalStore` comes at a cost though, since it forces a bail out from concurrent features like transitions, and forces existing content to show Suspense fallbacks.
+Usare `useSyncExternalStore` ha però un costo, poiché forza un bail out dalle funzionalità concurrent come le transizioni, e forza il contenuto esistente a mostrare fallback Suspense.
-Now that React 19 has shipped, we're revisiting this problem space to create a primitive to fully support concurrent external stores with the `use` API:
+Ora che React 19 è stato rilasciato, stiamo rivisitando questo spazio problematico per creare un primitivo che supporti completamente store esterni concurrent con l'API `use`:
```js
const value = use(store);
```
-Our goal is to allow external state to be read during render without tearing, and to work seamlessly with all of the concurrent features React offers.
+Il nostro obiettivo è permettere di leggere state esterno durante la renderizzazione senza tearing, e funzionare perfettamente con tutte le funzionalità concurrent che React offre.
-This research is still early. We'll share more, and what the new APIs will look like, when we're further along.
+Questa ricerca è ancora agli inizi. Condivideremo di più, e come saranno le nuove API, quando saremo più avanti.
---
-_Thanks to [Aurora Scharff](https://bsky.app/profile/aurorascharff.no), [Dan Abramov](https://bsky.app/profile/danabra.mov), [Eli White](https://twitter.com/Eli_White), [Lauren Tan](https://bsky.app/profile/no.lol), [Luna Wei](https://github.com/lunaleaps), [Matt Carroll](https://twitter.com/mattcarrollcode), [Jack Pope](https://jackpope.me), [Jason Bonta](https://threads.net/someextent), [Jordan Brown](https://github.com/jbrown215), [Jordan Eldredge](https://bsky.app/profile/capt.dev), [Mofei Zhang](https://threads.net/z_mofei), [Sebastien Lorber](https://bsky.app/profile/sebastienlorber.com), [Sebastian Markbåge](https://bsky.app/profile/sebmarkbage.calyptus.eu), and [Tim Yung](https://github.com/yungsters) for reviewing this post._
+_Grazie a [Aurora Scharff](https://bsky.app/profile/aurorascharff.no), [Dan Abramov](https://bsky.app/profile/danabra.mov), [Eli White](https://twitter.com/Eli_White), [Lauren Tan](https://bsky.app/profile/no.lol), [Luna Wei](https://github.com/lunaleaps), [Matt Carroll](https://twitter.com/mattcarrollcode), [Jack Pope](https://jackpope.me), [Jason Bonta](https://threads.net/someextent), [Jordan Brown](https://github.com/jbrown215), [Jordan Eldredge](https://bsky.app/profile/capt.dev), [Mofei Zhang](https://threads.net/z_mofei), [Sebastien Lorber](https://bsky.app/profile/sebastienlorber.com), [Sebastian Markbåge](https://bsky.app/profile/sebmarkbage.calyptus.eu), e [Tim Yung](https://github.com/yungsters) per la revisione di questo post._