{}, url: document.location.pathname});
function navigate(url) {
startTransition(() => {
- // Transition type for the cause "nav forward"
+ // Tipo de transição para a causa "nav forward"
addTransitionType('nav-forward');
go(url);
});
}
function navigateBack(url) {
startTransition(() => {
- // Transition type for the cause "nav backward"
+ // Tipo de transição para a causa "nav backward"
addTransitionType('nav-back');
go(url);
});
@@ -13416,13 +13416,13 @@ export function Router({ children }) {
useEffect(() => {
function handlePopState() {
- // This should not animate because restoration has to be synchronous.
- // Even though it's a transition.
+ // Isto não deve ser animado, porque a restauração precisa ser síncrona.
+ // Mesmo sendo uma transição.
startTransition(() => {
setRouterState({
url: document.location.pathname + document.location.search,
pendingNav() {
- // Noop. URL has already updated.
+ // Não faz nada. A URL já foi atualizada.
},
});
});
@@ -14034,7 +14034,7 @@ ul {
```css src/animations.css
-/* No additional animations needed */
+/* Nenhuma animação adicional necessária */
@@ -14044,14 +14044,14 @@ ul {
-/* Previously defined animations below */
+/* Animações definidas anteriormente abaixo */
-/* Slide animations for Suspense the fallback down */
+/* Animações de deslizar do Suspense: o fallback para baixo */
::view-transition-old(.slide-down) {
animation: 150ms ease-out both fade-out, 150ms ease-out both slide-down;
}
@@ -14060,32 +14060,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 */
+/* Animações para as classes de view transition adicionadas pelo tipo de transição */
::view-transition-old(.slide-forward) {
- /* when sliding forward, the "old" page should slide out to left. */
+ /* ao deslizar para frente, a página "antiga" deve sair deslizando para a esquerda. */
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. */
+ /* ao deslizar para frente, a página "nova" deve entrar deslizando pela direita. */
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. */
+ /* ao deslizar para trás, a página "antiga" deve sair deslizando para a direita. */
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. */
+ /* ao deslizar para trás, a página "nova" deve entrar deslizando pela esquerda. */
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. */
+/* Keyframes que dão suporte às animações acima. */
@keyframes slide-up {
from {
transform: translateY(10px);
@@ -14146,7 +14146,7 @@ ul {
}
}
-/* Default .slow-fade. */
+/* .slow-fade padrão. */
::view-transition-old(.slow-fade) {
animation-duration: 500ms;
}
@@ -14193,45 +14193,45 @@ root.render(
-### Server-Side Rendering with Activity {/*server-side-rendering-with-activity*/}
+### Renderização do lado do servidor com Activity {/*server-side-rendering-with-activity*/}
-When using Activity on a page that uses server-side rendering (SSR), there are additional optimizations.
+Ao usar Activity em uma página que usa renderização do lado do servidor (SSR), há otimizações adicionais.
-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 da página for renderizada com `mode="hidden"`, ela não vai ser incluída na resposta do SSR. Em vez disso, o React vai agendar uma renderização no cliente para o conteúdo dentro da Activity enquanto o restante da página é hidratado, priorizando o conteúdo visível na tela.
-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.
+Para partes da UI renderizadas com `mode="visible"`, o React vai reduzir a prioridade da hidratação do conteúdo dentro da Activity, de forma parecida com o modo como o conteúdo do Suspense é hidratado com prioridade menor. Se o usuário interagir com a página, vamos priorizar a hidratação dentro do limite, se necessário.
-These are advanced use cases, but they show the additional benefits considered with Activity.
+Esses são casos de uso avançados, mas mostram os benefícios adicionais pensados para a Activity.
-### Future modes for Activity {/*future-modes-for-activity*/}
+### Modos futuros para Activity {/*future-modes-for-activity*/}
-In the future, we may add more modes to Activity.
+No futuro, podemos adicionar mais modos à 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.
+Por exemplo, um caso de uso comum é renderizar um modal, em que a página anterior, "inativa", fica visível atrás da visualização "ativa" do modal. O modo "hidden" não funciona para esse caso de uso, porque o conteúdo não fica visível e não é incluído no 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.
+Em vez disso, estamos considerando um novo modo que manteria o conteúdo visível—e incluído no SSR—mas o deixaria desmontado e com atualizações de prioridade reduzida. Esse modo também pode precisar "pausar" atualizações do DOM, já que pode distrair ver o conteúdo do fundo sendo atualizado enquanto um modal está aberto.
-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.
+Outro modo que estamos considerando para a Activity é a capacidade de destruir automaticamente o estado de Activities ocultas se houver memória demais sendo usada. Como o componente já está desmontado, pode ser preferível destruir o estado das partes ocultas do app usadas há mais tempo do que consumir recursos demais.
-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).
+Essas são áreas que ainda estamos explorando, e vamos compartilhar mais à medida que avançarmos. Para mais informações sobre o que a Activity inclui hoje, [confira a documentação](/reference/react/Activity).
---
-# Features in development {/*features-in-development*/}
+# Recursos em desenvolvimento {/*features-in-development*/}
-We're also developing features to help solve the common problems below.
+Também estamos desenvolvendo recursos para ajudar a resolver os problemas comuns abaixo.
-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.
+À medida que iteramos sobre possíveis soluções, você pode ver algumas APIs em teste sendo compartilhadas com base nos PRs que estamos integrando. Tenha em mente que, conforme testamos ideias diferentes, muitas vezes mudamos ou removemos soluções depois de experimentá-las.
-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 as soluções em que estamos trabalhando são compartilhadas cedo demais, isso pode gerar retrabalho e confusão na comunidade. Para equilibrar transparência e menos confusão, estamos compartilhando os problemas para os quais estamos desenvolvendo soluções, sem compartilhar uma solução específica que temos em mente.
-As these features progress, we'll announce them on the blog with docs included so you can try them out.
+À medida que esses recursos avançarem, vamos anunciá-los no blog, com documentação, para que você possa testá-los.
## 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.
+Estamos trabalhando em um novo conjunto de trilhas personalizadas para profilers de desempenho, usando APIs do navegador que [permitem adicionar trilhas personalizadas](https://developer.chrome.com/docs/devtools/performance/extension), para fornecer mais informações sobre o desempenho do seu 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:
+Esse recurso ainda está em andamento, então ainda não estamos prontos para publicar a documentação e lançá-lo por completo como recurso experimental. Você pode ter uma prévia usando uma versão experimental do React, que adiciona automaticamente as trilhas de desempenho aos perfis:
@@ -14244,53 +14244,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.
+Há alguns problemas conhecidos que planejamos resolver, como desempenho e a trilha do scheduler que nem sempre "conecta" o trabalho entre árvores suspensas, então ainda não está pronto para teste. Também ainda estamos coletando feedback de quem adotou cedo para melhorar o design e a usabilidade das trilhas.
-Once we solve those issues, we'll publish experimental docs and share that it's ready to try.
+Quando resolvermos esses problemas, vamos publicar a documentação experimental e avisar que está pronto para teste.
---
-## Automatic Effect Dependencies {/*automatic-effect-dependencies*/}
+## Dependências automáticas de Effects {/*automatic-effect-dependencies*/}
-When we released hooks, we had three motivations:
+Quando lançamos os Hooks, tínhamos três motivações:
-- **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.
+- **Compartilhar código entre componentes**: os Hooks substituíram padrões como render props e componentes de ordem superior, permitindo reutilizar lógica com estado sem mudar a hierarquia de componentes.
+- **Pensar em termos de função, não de ciclos de vida**: os Hooks permitem dividir um componente em funções menores com base nas partes relacionadas (como configurar uma inscrição ou buscar dados), em vez de forçar uma divisão com base em métodos de ciclo de vida.
+- **Suportar compilação antecipada (ahead-of-time)**: os Hooks foram projetados para suportar compilação antecipada com menos armadilhas que causam desotimizações não intencionais por métodos de ciclo de vida e pelas limitações das classes.
-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.
+Desde o lançamento, os Hooks têm sido bem-sucedidos em *compartilhar código entre componentes*. Hoje, os Hooks são a forma preferida de compartilhar lógica entre componentes, e há menos casos de uso para render props e componentes de ordem superior. Os Hooks também foram bem-sucedidos em dar suporte a recursos como o Fast Refresh, que não eram possíveis com componentes de classe.
-### Effects can be hard {/*effects-can-be-hard*/}
+### Effects podem ser difíceis {/*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.
+Infelizmente, ainda é difícil pensar em alguns Hooks em termos de função, e não de ciclos de vida. Effects, em especial, ainda são difíceis de entender e são o ponto de dor mais comum que ouvimos de desenvolvedores. No ano passado, passamos bastante tempo pesquisando como os Effects eram usados e como esses casos de uso poderiam ser simplificados e ficar mais fáceis de entender.
-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.
+Descobrimos que, muitas vezes, a confusão vem de usar um Effect quando não é necessário. O guia [Você talvez não precise de um Effect](/learn/you-might-not-need-an-effect) cobre muitos casos em que Effects não são a solução certa. No entanto, mesmo quando um Effect é a escolha certa para um problema, Effects ainda podem ser mais difíceis de entender do que os ciclos de vida de componentes de 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).
+Acreditamos que um dos motivos da confusão é que desenvolvedores pensam em Effects da perspectiva do _componente_ (como um ciclo de vida), em vez do ponto de vista do _Effect_ (o que o Effect faz).
-Let's look at an example [from the docs](/learn/lifecycle-of-reactive-effects#thinking-from-the-effects-perspective):
+Vamos ver um exemplo [da documentação](/learn/lifecycle-of-reactive-effects#thinking-from-the-effects-perspective):
```js
useEffect(() => {
- // Your Effect connected to the room specified with roomId...
+ // O seu Effect se conectou à sala especificada por roomId...
const connection = createConnection(serverUrl, roomId);
connection.connect();
return () => {
- // ...until it disconnected
+ // ...até se desconectar
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.
+Muitos usuários leriam este código como "ao montar, conecte ao roomId. Sempre que `roomId` mudar, desconecte da sala antiga e recrie a conexão". No entanto, isso é pensar da perspectiva do ciclo de vida do componente, o que significa que você vai precisar pensar em cada estado do ciclo de vida do componente para escrever o Effect corretamente. Isso pode ser difícil, então é compreensível que Effects pareçam mais difíceis do que os ciclos de vida de classe quando se usa a perspectiva do componente.
-### Effects without dependencies {/*effects-without-dependencies*/}
+### Effects sem dependências {/*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.
+Em vez disso, é melhor pensar da perspectiva do Effect. O Effect não sabe nada sobre os ciclos de vida do componente. Ele só descreve como começar a sincronização e como pará-la. Quando os usuários pensam em Effects dessa forma, os Effects tendem a ser mais fáceis de escrever e mais resilientes a serem iniciados e parados quantas vezes for necessário.
-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'.
+Passamos um tempo pesquisando por que se pensa em Effects da perspectiva do componente, e achamos que um dos motivos é o array de dependências. Como você precisa escrevê-lo, ele fica ali, bem na sua frente, lembrando você do que está "reagindo" e induzindo ao modelo mental de 'faça isto quando estes valores mudarem'.
-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 lançamos os Hooks, sabíamos que poderíamos torná-los mais fáceis de usar com compilação antecipada. Com o React Compiler, agora você consegue evitar escrever `useCallback` e `useMemo` na maioria dos casos. Para Effects, o compilador pode inserir as dependências por você:
```js
useEffect(() => {
@@ -14299,67 +14299,67 @@ useEffect(() => {
return () => {
connection.disconnect();
};
-}); // compiler inserted dependencies.
+}); // dependências inseridas pelo compilador.
```
-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.
+Com este código, o React Compiler pode inferir as dependências e inseri-las automaticamente, para que você não precise vê-las nem escrevê-las. Com recursos como [a extensão para IDE](#compiler-ide-extension) e [`useEffectEvent`](/reference/react/useEffectEvent), podemos oferecer um CodeLens que mostra o que o compilador inseriu, para quando você precisar depurar ou otimizar removendo uma dependência. Isso ajuda a reforçar o modelo mental correto para escrever Effects, que podem ser executados a qualquer momento para sincronizar o estado do seu componente ou Hook com outra coisa.
-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.
+A nossa esperança é que inserir dependências automaticamente não só seja mais fácil de escrever, mas também torne os Effects mais fáceis de entender, forçando você a pensar no que o Effect faz, e não nos ciclos de vida do componente.
---
-## Compiler IDE Extension {/*compiler-ide-extension*/}
+## Extensão do compilador para IDE {/*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.
+Mais tarde, em 2025, [compartilhamos](/blog/2025/10/07/react-compiler-1) a primeira versão estável do React Compiler, e continuamos investindo em lançar mais melhorias.
-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).
+Também começamos a explorar formas de usar o React Compiler para fornecer informações que ajudem a entender e depurar o seu código. Uma ideia que começamos a explorar é uma nova extensão experimental de React para IDEs, baseada em LSP e alimentada pelo React Compiler, parecida com a extensão usada na [palestra de Lauren Tan na 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).
+A nossa ideia é usar a análise estática do compilador para fornecer mais informações, sugestões e oportunidades de otimização diretamente na sua IDE. Por exemplo, podemos fornecer diagnósticos para código que quebra as Regras do React, informações ao passar o mouse mostrando se componentes e Hooks foram otimizados pelo compilador, ou um CodeLens para ver as [dependências de Effects inseridas automaticamente](#automatic-effect-dependencies).
-The IDE extension is still an early exploration, but we'll share our progress in future updates.
+A extensão para IDE ainda é uma exploração inicial, mas vamos compartilhar o nosso progresso em atualizações futuras.
---
## 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).
+Muitas APIs do DOM, como as de gerenciamento de eventos, posicionamento e foco, são difíceis de compor quando se escreve com React. Isso muitas vezes leva desenvolvedores a recorrer a Effects, gerenciando várias Refs, usando APIs como `findDOMNode` (removida no 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.
+Estamos explorando adicionar refs a Fragments, que apontariam para um grupo de elementos do DOM, e não apenas para um único elemento. A nossa esperança é que isso simplifique o gerenciamento de vários filhos e facilite escrever código React componível ao chamar APIs do DOM.
-Fragment refs are still being researched. We'll share more when we're closer to having the final API finished.
+Fragment refs ainda estão sendo pesquisadas. Vamos compartilhar mais quando estivermos mais perto de ter a API final.
---
-## Gesture Animations {/*gesture-animations*/}
+## Animações de gestos {/*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.
+Também estamos pesquisando formas de aprimorar as View Transitions para suportar animações de gestos, como deslizar para abrir um menu ou rolar por um carrossel de fotos.
-Gestures present new challenges for a few reasons:
+Gestos trazem novos desafios por alguns motivos:
-- **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.
+- **Gestos são contínuos**: enquanto você desliza, a animação fica atrelada à posição do seu dedo ao longo do tempo, em vez de ser disparada e executada até o fim.
+- **Gestos não se completam**: quando você solta o dedo, as animações de gesto podem ser executadas até o fim ou voltar ao estado original (como quando você só abre um menu parcialmente), dependendo de até onde você foi.
+- **Gestos invertem o antigo e o novo**: enquanto você está animando, quer que a página de onde a animação parte continue "viva" e interativa. Isso inverte o modelo de View Transition do navegador, em que o estado "antigo" é um snapshot e o estado "novo" é o DOM ao vivo.
-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.
+Acreditamos ter encontrado uma abordagem que funciona bem e talvez introduza uma nova API para disparar transições de gestos. Por enquanto, estamos focados em lançar o `` e vamos voltar aos gestos depois.
---
## 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 lançamos o React 18 com renderização concorrente, também lançamos o `useSyncExternalStore`, para que bibliotecas de stores externos que não usavam estado nem contexto do React pudessem [dar suporte à renderização concorrente](https://github.com/reactwg/react-18/discussions/70), forçando uma renderização síncrona quando o store é atualizado.
-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.
+Usar `useSyncExternalStore` tem um custo, porém, já que força a saída de recursos concorrentes como transições e força o conteúdo existente a mostrar fallbacks do 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:
+Agora que o React 19 foi lançado, estamos revisitando esse problema para criar uma primitiva que suporte por completo stores externos concorrentes com a 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.
+O nosso objetivo é permitir que o estado externo seja lido durante a renderização sem tearing e funcione perfeitamente com todos os recursos concorrentes que o React oferece.
-This research is still early. We'll share more, and what the new APIs will look like, when we're further along.
+Essa pesquisa ainda está no início. Vamos compartilhar mais, inclusive como vão ser as novas APIs, quando estivermos mais adiantados.
---
-_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._
+_Agradecemos 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) pela revisão desta publicação._
From 62795c636689e9ded5eb9ce4b1c09f61d2d34d16 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jo=C3=A3o=20Figueredo?=
<63759223+jpfigueredo@users.noreply.github.com>
Date: Sat, 21 Nov 2026 16:55:57 -0300
Subject: [PATCH 2/2] =?UTF-8?q?Mant=C3=A9m=20"state"=20em=20ingl=C3=AAs=20?=
=?UTF-8?q?nos=20coment=C3=A1rios=20de=20c=C3=B3digo?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...labs-view-transitions-activity-and-more.md | 38 +++++++++----------
1 file changed, 19 insertions(+), 19 deletions(-)
diff --git a/src/content/blog/2025/04/23/react-labs-view-transitions-activity-and-more.md b/src/content/blog/2025/04/23/react-labs-view-transitions-activity-and-more.md
index 291b6f5781..986d452969 100644
--- a/src/content/blog/2025/04/23/react-labs-view-transitions-activity-and-more.md
+++ b/src/content/blog/2025/04/23/react-labs-view-transitions-activity-and-more.md
@@ -395,7 +395,7 @@ import {useState} from 'react';
import {Heart} from './Icons';
// Uma gambiarra, já que não temos um backend de verdade.
-// Diferente do estado local, isto sobrevive à filtragem dos vídeos.
+// Diferente do state local, isto sobrevive à filtragem dos vídeos.
const likedVideos = new Set();
export default function LikeButton({video}) {
@@ -604,14 +604,14 @@ export function Router({ children }) {
});
}
function navigate(url) {
- // Atualiza o estado do roteador em uma transição.
+ // Atualiza o state do roteador em uma transição.
startTransition(() => {
go(url);
});
}
function navigateBack(url) {
- // Atualiza o estado do roteador em uma transição.
+ // Atualiza o state do roteador em uma transição.
startTransition(() => {
go(url);
});
@@ -1593,7 +1593,7 @@ import {useState} from 'react';
import {Heart} from './Icons';
// Uma gambiarra, já que não temos um backend de verdade.
-// Diferente do estado local, isto sobrevive à filtragem dos vídeos.
+// Diferente do state local, isto sobrevive à filtragem dos vídeos.
const likedVideos = new Set();
export default function LikeButton({video}) {
@@ -1773,7 +1773,7 @@ export function Router({ children }) {
const [isPending, startTransition] = useTransition();
function navigate(url) {
- // Atualiza o estado do roteador em uma transição.
+ // Atualiza o state do roteador em uma transição.
startTransition(() => {
go(url);
});
@@ -2807,7 +2807,7 @@ import {useState} from 'react';
import {Heart} from './Icons';
// Uma gambiarra, já que não temos um backend de verdade.
-// Diferente do estado local, isto sobrevive à filtragem dos vídeos.
+// Diferente do state local, isto sobrevive à filtragem dos vídeos.
const likedVideos = new Set();
export default function LikeButton({video}) {
@@ -3016,14 +3016,14 @@ export function Router({ children }) {
});
}
function navigate(url) {
- // Atualiza o estado do roteador em uma transição.
+ // Atualiza o state do roteador em uma transição.
startTransition(() => {
go(url);
});
}
function navigateBack(url) {
- // Atualiza o estado do roteador em uma transição.
+ // Atualiza o state do roteador em uma transição.
startTransition(() => {
go(url);
});
@@ -4001,7 +4001,7 @@ import {useState} from 'react';
import {Heart} from './Icons';
// Uma gambiarra, já que não temos um backend de verdade.
-// Diferente do estado local, isto sobrevive à filtragem dos vídeos.
+// Diferente do state local, isto sobrevive à filtragem dos vídeos.
const likedVideos = new Set();
export default function LikeButton({video}) {
@@ -4210,14 +4210,14 @@ export function Router({ children }) {
});
}
function navigate(url) {
- // Atualiza o estado do roteador em uma transição.
+ // Atualiza o state do roteador em uma transição.
startTransition(() => {
go(url);
});
}
function navigateBack(url) {
- // Atualiza o estado do roteador em uma transição.
+ // Atualiza o state do roteador em uma transição.
startTransition(() => {
go(url);
});
@@ -5263,7 +5263,7 @@ import {useState} from 'react';
import {Heart} from './Icons';
// Uma gambiarra, já que não temos um backend de verdade.
-// Diferente do estado local, isto sobrevive à filtragem dos vídeos.
+// Diferente do state local, isto sobrevive à filtragem dos vídeos.
const likedVideos = new Set();
export default function LikeButton({video}) {
@@ -6535,7 +6535,7 @@ import {useState} from 'react';
import {Heart} from './Icons';
// Uma gambiarra, já que não temos um backend de verdade.
-// Diferente do estado local, isto sobrevive à filtragem dos vídeos.
+// Diferente do state local, isto sobrevive à filtragem dos vídeos.
const likedVideos = new Set();
export default function LikeButton({video}) {
@@ -7856,7 +7856,7 @@ import {useState} from 'react';
import {Heart} from './Icons';
// Uma gambiarra, já que não temos um backend de verdade.
-// Diferente do estado local, isto sobrevive à filtragem dos vídeos.
+// Diferente do state local, isto sobrevive à filtragem dos vídeos.
const likedVideos = new Set();
export default function LikeButton({video}) {
@@ -9183,7 +9183,7 @@ import {useState} from 'react';
import {Heart} from './Icons';
// Uma gambiarra, já que não temos um backend de verdade.
-// Diferente do estado local, isto sobrevive à filtragem dos vídeos.
+// Diferente do state local, isto sobrevive à filtragem dos vídeos.
const likedVideos = new Set();
export default function LikeButton({video}) {
@@ -10498,7 +10498,7 @@ import {useState} from 'react';
import {Heart} from './Icons';
// Uma gambiarra, já que não temos um backend de verdade.
-// Diferente do estado local, isto sobrevive à filtragem dos vídeos.
+// Diferente do state local, isto sobrevive à filtragem dos vídeos.
const likedVideos = new Set();
export default function LikeButton({video}) {
@@ -11551,7 +11551,7 @@ export default function App() {
return (
// View Transitions sabem lidar com Activity
- {/* Renderiza Home em Activity para não perdermos o estado */}
+ {/* Renderiza Home em Activity para não perdermos o state */}
@@ -11869,7 +11869,7 @@ import {useState} from 'react';
import {Heart} from './Icons';
// Uma gambiarra, já que não temos um backend de verdade.
-// Diferente do estado local, isto sobrevive à filtragem dos vídeos.
+// Diferente do state local, isto sobrevive à filtragem dos vídeos.
const likedVideos = new Set();
export default function LikeButton({video}) {
@@ -13207,7 +13207,7 @@ import {useState} from 'react';
import {Heart} from './Icons';
// Uma gambiarra, já que não temos um backend de verdade.
-// Diferente do estado local, isto sobrevive à filtragem dos vídeos.
+// Diferente do state local, isto sobrevive à filtragem dos vídeos.
const likedVideos = new Set();
export default function LikeButton({video}) {