This is a code from a React Application, that receive a large amount of data and…
- User
This is a code from a React Application, that receive a large amount of data and displays in diverse ways, that can be in different internal tabs. But it's slow. I need an improvement for fix code mistakes and a better run:
import { Icon } from '@components/Atoms'; import { BadgeStatus } from '@components/Molecules'; import { Skeleton, Tabs } from '@mantine/core'; import { Bloco, Card, Content } from '@src/components/Atoms/Library'; import { CardCountDays } from '@src/components/Organisms/CardCountDays'; import { MainProgressBar } from '@src/components/Organisms/MainProgressBar'; import { getObra, medicoesByObraID, medicoesItemsByMedicaoID, planilhaItemsByPlanilhaID, planilhasByObraID, } from '@src/graphql/queries'; import { Medicao, MedicaoItem, Obra, PlanilhaData, PlanilhaItemData } from '@src/utils/interfaces'; import { bgStatus } from '@src/utils/interfaces/status.enum'; import { generateClient } from 'aws-amplify/api'; import dayjs from 'dayjs'; import { useCallback, useEffect, useMemo, useState } from 'react'; import { useParams } from 'react-router-dom'; import { CardAddDesconto } from './obras.add-desconto'; import { AddMedicao, MergedData } from './obras.add-medicao'; import { CardSetStart } from './obras.set-start'; import { ViewConsolidado } from './obras.view-consolidado'; import { ViewMedicao } from './obras.view-medicao'; import { ViewPlanilhaOrcamentaria } from './obras.view-planilha';
const client = generateClient();
type Tabs = 'consolidado' | 'planilha' | 'add_medicao';
const ObrasView = () => { const { id } = useParams<{ id: string }>(); const [errorID, setErrorID] = useState(false);
const [responseObraData, setResponseObraData] = useState<Obra | null>(null);
const [planilhaData, setPlanilhaData] = useState<PlanilhaData | null>(null); const [planilhaItemData, setPlanilhaItemData] = useState<PlanilhaItemData[]>([]);
const [medicoesInfo, setMedicoesInfo] = useState<Medicao[]>([]); const [lastMedicaoItem, setLastMedicaoItem] = useState<MedicaoItem[]>([]); const [nextMedicaoNum, setNextMedicaoNum] = useState(1); const [currentMedicaoData, setCurrentMedicaoData] = useState<MedicaoItem[]>([]); const [acumuladoPercent, setAcumuladoPercent] = useState('');
const { tabValue } = useParams<{ tabValue: string }>(); const [activeTab, setActiveTab] = useState<string | null>(tabValue || 'consolidado'); const [fetchedMedicaoData, setFetchedMedicaoData] = useState<{ [key: string]: MedicaoItem[] }>( {} );
// Para nova medição, dados já mergeados const [processedData, setProcessedData] = useState<MergedData[]>([]); const handleUpdateProcessedData = useCallback((newProcessedData: MergedData[]) => { setProcessedData(newProcessedData); }, []);
// Busca por dados da Obra const fetchObra = useCallback(async () => { if (!id) return null;
const response = (await client.graphql({ query: getObra, variables: { id: id }, })) as unknown as { data: { getObra: Obra } }; if (!response.data.getObra) setErrorID(true); return response.data.getObra as Obra;}, [id]);
useEffect(() => { const fetchData = async () => { const data = await fetchObra(); if (!data) return;
setResponseObraData(data); setAcumuladoPercent(((data.valorAcumulado / data.valorTotal) * 100).toFixed(2)); if ((data.status ?? 0) > 1) { fetchMedicoes(data.id); } fetchPlanilha(data.id); }; fetchData();}, [fetchObra]);
const obraData = useMemo(() => responseObraData, [responseObraData]);
// Busca por dados da Planilha const fetchPlanilha = async (obraID: string) => { const planilhasResponse = await client.graphql({ query: planilhasByObraID, variables: { obraID: obraID }, });
const planilhasData = planilhasResponse.data.planilhasByObraID.items; setPlanilhaData(planilhasData[0]); const itemsResponse = (await client.graphql({ query: planilhaItemsByPlanilhaID, variables: { planilhaID: planilhasData[0].id, limit: 1500 }, })) as unknown as { data: { planilhaItemsByPlanilhaID: { items: PlanilhaItemData[] } } }; const itemsData = itemsResponse.data.planilhaItemsByPlanilhaID.items; const itemsDataSorted = itemsData.sort( (a, b) => new Date(a.createdAt ?? '').getTime() - new Date(b.createdAt ?? '').getTime() ); setPlanilhaItemData(itemsDataSorted);};
// Busca por Medições desta Obra const fetchMedicoes = async (obraID: string) => { const medicaoResponse = await client.graphql({ query: medicoesByObraID, variables: { obraID: obraID }, });
const medicaoData = medicaoResponse.data.medicoesByObraID.items; // Se encontrou medições, salva resultados e busca dados da última medição if (medicaoData.length > 0) { setNextMedicaoNum(medicaoData.length + 1); medicaoData.sort((a, b) => a.medicaoNum - b.medicaoNum); const medicoesInfoConverted: Medicao[] = medicaoData.map((item) => ({ id: item.id ?? '', medicaoNum: item.medicaoNum ?? 0, dataMedicao: item.dataMedicao ?? '', userCreatedAt: item.userCreatedAt ?? '', valorTotal: item.valorTotal ?? 0, valorTotalMaodeObra: item.valorTotalMaodeObra ?? 0, valorTotalMaterial: item.valorTotalMaterial ?? 0, valorAcumulado: item.valorAcumulado ?? 0, valorSaldo: item.valorSaldo ?? 0, })); setMedicoesInfo(medicoesInfoConverted); const lastMedicao = medicaoData[medicaoData.length - 1]; const lastMedicaoResponse = await client.graphql({ query: medicoesItemsByMedicaoID, variables: { medicaoID: lastMedicao.id, limit: 500 }, }); const lastMedicaoData = lastMedicaoResponse.data.medicoesItemsByMedicaoID.items; const lastMedicaoDataItems: MedicaoItem[] = lastMedicaoData.map((item) => ({ item: item.item ?? '', qtdMedicao: Number(item.qtdMedicao), valorTotal: item.valorTotal ?? null, valorTotalPerc: item.valorTotalPerc ?? null, acumulado: item.acumulado ?? null, acumuladoPerc: item.acumuladoPerc ?? null, saldoQtd: item.saldoQtd ?? null, saldoValor: item.saldoValor ?? null, saldoValorPerc: item.saldoValorPerc ?? null, })); setLastMedicaoItem(lastMedicaoDataItems); }};
const handleMedicaoChange = async (medicaoID: string) => { // Verifica se os dados para o medicaoID atual já foram buscados if (fetchedMedicaoData[medicaoID]) { // Se os dados já existirem, use-os diretamente setCurrentMedicaoData(fetchedMedicaoData[medicaoID]); } else { // Se os dados não existirem, faça a consulta ao banco de dados const response = await client.graphql({ query: medicoesItemsByMedicaoID, variables: { medicaoID: medicaoID, limit: 500 }, });
const currentMedicaoData = response.data.medicoesItemsByMedicaoID.items; window.log('currentMedicaoData', currentMedicaoData); const medicaoDataConverted: MedicaoItem[] = currentMedicaoData.map((item) => ({ item: item.item ?? '', qtdMedicao: item.qtdMedicao ?? null, valorTotal: item.valorTotal ?? null, valorTotalPerc: item.valorTotalPerc ?? null, acumulado: item.acumulado ?? null, acumuladoPerc: item.acumuladoPerc ?? null, saldoQtd: item.saldoQtd ?? null, saldoValor: item.saldoValor ?? null, saldoValorPerc: item.saldoValorPerc ?? null, })); // Armazena os dados buscados no estado fetchedMedicaoData setFetchedMedicaoData((prevState) => ({ ...prevState, [medicaoID]: medicaoDataConverted, })); setCurrentMedicaoData(medicaoDataConverted); }};
const showTabMedicao = useCallback((medicaoNum: number, medicaoID: string) => { setCurrentMedicaoData([]); setActiveTab(
medicao_${medicaoNum}); handleMedicaoChange(medicaoID); }, []);if (!id || errorID) return ( Obra não encontrada! );
const statusBackground = bgStatus[obraData?.status ?? 5];
const classes = { titleBlock: 'p-5 border-b border-white-light min-h-[110px]', progressBlock:
gap-5 p-5 ${statusBackground}, acumuladoPercent: 'font-display font-bold text-white lg:text-5xl text-4xl', tab:relative text-base mx-0.5 border border-gray-200 z-10, toActiveTab:mt-1 border-b-2 hover:bg-gray-100 bg-white, activeTab: 'bg-blue-500 border-blue-500 text-white hover:bg-blue-600', };if (!obraData) return ( <> </> );
return ( <> {obraData?.nomeObra} {obraData?.contrato && ( Contrato: {obraData?.contrato} )} {obraData?.Campus?.nomeCampus}
{/* Bloco de progresso */} <Bloco horizontal justify="between" className={classes.progressBlock}> {/* Cards de Datas */} {obraData?.dataInicio && obraData?.dataFim && ( <Card p="4" className="basis-3/6 max-lg:basis-4/6 justify-between"> <CardCountDays obraData={obraData} /> </Card> )} {medicoesInfo.length > 0 && ( <Card shadow withBorder className="basis-2/6"> <small>Última Medição</small> <span className="lead mt-2"> {dayjs(medicoesInfo[medicoesInfo.length - 1]?.dataMedicao).format('DD.MM.YY')} </span> <p>{medicoesInfo[medicoesInfo.length - 1]?.userCreatedAt}</p> </Card> )} {obraData?.status === 0 && ( <Card shadow withBorder p="3" className="basis-2/6"> <CardAddDesconto tableData={planilhaItemData} obraID={id} /> </Card> )} {obraData?.status === 1 && ( <Card shadow withBorder p="3" className="basis-3/6"> <CardSetStart dataPrevista={obraData.dataInicio} obraID={id} duracao={obraData.duracao} /> </Card> )} {acumuladoPercent !== '0.00' && ( <Bloco vertical alignHorizontal="right" alignVertical="middle" className="max-lg:basis-1/6 basis-3/6" > <span className={classes.acumuladoPercent}>{acumuladoPercent}%</span> <small className="text-white">Completo</small> </Bloco> )} </Bloco> <MainProgressBar acumuladoPercent={acumuladoPercent} valorTotalObra={obraData?.valorTotal ?? 100} medicoesInfo={medicoesInfo} /> </Card> <Content className="px-3 mt-[86px]"> <Tabs className="w-full -mt-[76px]" radius="md" value={activeTab} onChange={setActiveTab}> {/* Tabs */} <Tabs.List className="z-20"> <Tabs.Tab value="consolidado" className={`${classes.tab} ${ activeTab === 'consolidado' ? classes.activeTab : classes.toActiveTab } ml-0`} onClick={() => setActiveTab('consolidado')} > Consolidado </Tabs.Tab> <Tabs.Tab value="planilha" className={`${classes.tab} ${ activeTab === 'planilha' ? classes.activeTab : classes.toActiveTab }`} onClick={() => setActiveTab('planilha')} > Planilha Orçamentária </Tabs.Tab> {medicoesInfo.map((medicao) => ( <Tabs.Tab key={medicao.medicaoNum} value={`medicao_${medicao.medicaoNum}`} className={`${classes.tab} ${ activeTab === `medicao_${medicao.medicaoNum}` ? classes.activeTab : classes.toActiveTab }`} onClick={() => showTabMedicao(medicao.medicaoNum, medicao.id)} > Medição {medicao.medicaoNum} </Tabs.Tab> ))} {Number(obraData?.status) > 1 && acumuladoPercent !== '100.00' && ( <Tabs.Tab value="add_medicao" className={`${classes.tab} ${ activeTab === 'add_medicao' ? classes.activeTab : classes.toActiveTab } text-lg font-bold mr-0`} onClick={() => setActiveTab('add_medicao')} ml="auto" leftSection={<Icon name="BiSolidAddToQueue" propsIcon={{ size: 24 }} />} > Nova Medição </Tabs.Tab> )} </Tabs.List> {/* Conteúdo Tabs */} <Tabs.Panel value="consolidado"> <h3 className="text-blue-900 py-6 px-2">Resumo da Obra com Medições</h3> <ViewConsolidado planilhaItemData={planilhaItemData} medicoesInfo={medicoesInfo} medicoesItemData={lastMedicaoItem} showTabMedicao={showTabMedicao} /> </Tabs.Panel> <Tabs.Panel value="planilha"> <h3 className="text-blue-900 py-5 px-2">Planilha Orçamentária Original</h3> {activeTab === 'planilha' && obraData && planilhaData && ( <ViewPlanilhaOrcamentaria planilhaData={planilhaData!} planilhaItemData={planilhaItemData} obraData={obraData} /> )} </Tabs.Panel> {medicoesInfo.map((medicao) => ( <Tabs.Panel value={`medicao_${medicao.medicaoNum}`} key={medicao.medicaoNum}> <h3 className="text-blue-900 py-5 px-2">Dados da Medição {medicao.medicaoNum}</h3> <ViewMedicao medicaoData={currentMedicaoData} medicaoInfo={medicao} planilhaItemData={planilhaItemData} /> </Tabs.Panel> ))} {activeTab === 'add_medicao' && ( <Tabs.Panel value="add_medicao"> <h3 className="text-blue-900 py-5 px-2">Nova Medição</h3> <AddMedicao tableData={planilhaItemData} medicoesData={lastMedicaoItem} obraID={id} dataInicio={obraData?.dataInicio || Date.now().toString()} nextMedicaoNum={nextMedicaoNum} processedData={processedData} onUpdateProcessedData={handleUpdateProcessedData} /> </Tabs.Panel> )} </Tabs> </Content> </>); };
export default ObrasView;
- Assistant
The code you've provided handles data fetching and rendering for a React application that deals with large datasets. Performance issues in such applications often arise from:
- Inefficient Data Fetching: Fetching large amounts of data at once.
- Unnecessary Re-renders: Components re-rendering when they shouldn't.
- Heavy Rendering in Child Components: Components that render large lists without optimization.
Here's how you can address these issues:
1. Optimize Data Fetching
Problem: You're fetching large datasets (
planilhaItemDatawith a limit of 1500 andmedicoesItemsByMedicaoIDwith a limit of 500) in one go, which can be slow and block the main thread.Solution: Implement pagination or lazy loading to fetch data in chunks.
Implementation:
-
Use Pagination for Data Fetching:
const fetchPlanilhaItems = async (planilhaID, nextToken = null) => { const response = await client.graphql({ query: planilhaItemsByPlanilhaID, variables: { planilhaID, limit: 100, // Fetch in smaller batches nextToken, }, }); const items = response.data.planilhaItemsByPlanilhaID.items; const newNextToken = response.data.planilhaItemsByPlanilhaID.nextToken; setPlanilhaItemData((prevItems) => [...prevItems, ...items]); if (newNextToken) { // Fetch the next batch fetchPlanilhaItems(planilhaID, newNextToken); } }; -
Use AWS Amplify’s Pagination Feature: Ensure your GraphQL queries include a
nextTokenfield to support pagination.
Benefits:
- Reduces the amount of data fetched at once.
- Improves initial load times.
- Allows the application to remain responsive while data loads incrementally.
2. Optimize Rendering of Large Lists
Problem: Rendering large lists (like
planilhaItemData) can be slow, especially if the list items are complex components.Solution: Use virtualization to only render items that are visible on the screen.
Implementation:
-
Use Libraries Like
react-window:import { FixedSizeList as List } from 'react-window'; const ItemList = () => ( <List height={500} itemCount={planilhaItemData.length} itemSize={35} width="100%" > {({ index, style }) => ( <div style={style}> {/* Render your item component */} <ItemComponent data={planilhaItemData[index]} /> </div> )} </List> ); -
Integrate Virtualization in Child Components: Ensure components like
ViewPlanilhaOrcamentariaandViewConsolidadouse virtualization for their lists.
Benefits:
- Improves rendering performance.
- Reduces memory usage.
- Enhances scroll performance.
3. Prevent Unnecessary Re-renders
Problem: Components re-render when their parent re-renders, even if their props haven't changed, especially when passing down functions or large data objects.
Solution:
- Use
React.memoto memoize components. - Use
useCallbackanduseMemoto memoize functions and computed values.
Implementation:
-
Memoize Child Components:
const ViewConsolidado = React.memo(({ /* props */ }) => { // component code }); -
Use
useCallbackfor Functions Passed as Props:const showTabMedicao = useCallback((medicaoNum, medicaoID) => { setCurrentMedicaoData([]); setActiveTab(`medicao_${medicaoNum}`); handleMedicaoChange(medicaoID); }, [handleMedicaoChange]); // Add dependencies -
Use
useMemofor Computed Values:const sortedPlanilhaItemData = useMemo(() => { return planilhaItemData.sort((a, b) => { // sorting logic }); }, [planilhaItemData]);
Benefits:
- Reduces unnecessary renders.
- Improves performance by ensuring components only re-render when their props change.
4. Improve State Management
Problem: Storing large datasets in state can cause performance issues, especially if state updates are frequent.
Solution:
- Avoid storing entire large datasets in state if possible.
- Use a state management library like Redux or MobX for better state management of large datasets.
- Use React Query for data fetching and caching.
Implementation:
-
Using React Query:
import { useQuery } from 'react-query'; const { data, error, isLoading } = useQuery(['planilhaItems', planilhaID], () => fetchPlanilhaItems(planilhaID) ); -
Benefits of React Query:
- Caches data to prevent unnecessary fetches.
- Provides built-in support for loading and error states.
- Simplifies data synchronization.
5. Error Handling and Edge Cases
Problem: The current code lacks proper error handling, which can lead to crashes or inconsistent states.
Solution:
- Implement try-catch blocks for async operations.
- Handle cases where data might be undefined or null.
Implementation:
-
Add Error Handling in Data Fetching Functions:
const fetchObra = useCallback(async () => { if (!id) return null; try { const response = await client.graphql({ query: getObra, variables: { id }, }); if (!response.data.getObra) setErrorID(true); return response.data.getObra; } catch (error) { console.error('Error fetching obra:', error); setErrorID(true); return null; } }, [id]); -
Check for Data Existence Before Accessing:
if (planilhasData && planilhasData.length > 0) { // proceed to use planilhasData[0] }
Benefits:
- Prevents the application from crashing.
- Provides a better user experience with proper error messages.
6. Code Refactoring and Clean-Up
Problem: The component has a lot of responsibilities, making it harder to maintain and potentially slower.
Solution:
- Break down the component into smaller, more focused components.
- Move data fetching logic to custom hooks.
Implementation:
-
Create Custom Hooks for Data Fetching:
const useObraData = (id) => { const [obraData, setObraData] = useState(null); useEffect(() => { // Fetch data and setObraData }, [id]); return obraData; }; -
Split Component Logic:
- Separate data fetching, state management, and rendering logic into different files or components.
Benefits:
- Improves code readability and maintainability.
- Makes it easier to test individual parts of the code.
- Potentially improves performance by isolating re-renders.
7. Consider Lazy Loading Tabs
Problem: All tabs are being initialized and possibly rendered on component mount, even if the user doesn't view them.
Solution:
- Implement lazy loading for tabs so that content is only loaded when the tab is active.
Implementation:
- Use
Suspenseandlazy:import { Suspense, lazy } from 'react'; const ViewConsolidado = lazy(() => import('./ViewConsolidado')); const ViewPlanilhaOrcamentaria = lazy(() => import('./ViewPlanilhaOrcamentaria')); // Other components... // In your tab panel <Tabs.Panel value="consolidado"> <Suspense fallback={<div>Loading...</div>}> <ViewConsolidado {...props} /> </Suspense> </Tabs.Panel>
Benefits:
- Reduces initial load time.
- Improves performance by loading components only when needed.
Summary of Key Changes
-
Data Fetching:
- Implement pagination.
- Use
nextTokenfor fetching large datasets in chunks.
-
Rendering Optimization:
- Use virtualization (
react-window). - Memoize components with
React.memo.
- Use virtualization (
-
State and Props Optimization:
- Use
useCallbackanduseMemo. - Avoid unnecessary state updates.
- Use
-
Error Handling:
- Add try-catch blocks.
- Check for data existence before using it.
-
Code Refactoring:
- Create custom hooks.
- Break down large components.
-
Lazy Loading:
- Implement lazy loading for tabs and components.
By implementing these changes, you should see significant improvements in the performance of your application. The key is to fetch and render only what's necessary and to prevent unnecessary computations and re-renders.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.