frst-components 0.37.0 → 0.38.0

package/dist/esm/src/components/DS/progressGoalBar/useProgressGoalBar.js

@@ -0,0 +1,232 @@
+import { useMemo } from 'react';
+import { MESSAGES } from './progressTexts.js';
+
+function toRange(start, end, current) {
+    if (start === end) {
+        return 25;
+    }
+    let porcentagem = ((current - start) / (end - start)) * 100;
+    if (porcentagem > 75) {
+        return 75;
+    }
+    else if (porcentagem < 28) {
+        return 28;
+    }
+    else {
+        return porcentagem;
+    }
+}
+var CurrentVariant;
+(function (CurrentVariant) {
+    CurrentVariant["Normal"] = "Normal";
+    CurrentVariant["Warning"] = "Warning";
+    CurrentVariant["Star"] = "star";
+})(CurrentVariant || (CurrentVariant = {}));
+const useProgressGoalBar = ({ start, current, goal }) => {
+    const endValue = start > goal ? start : goal;
+    const currentValue = current;
+    const isGoalReached = currentValue === goal;
+    const isNoGoal = currentValue === start;
+    const noGoal = (start < goal && currentValue < start) || (start > goal && currentValue > start);
+    const noResult = (start < goal && currentValue == start) || (start > goal && currentValue == start);
+    const resultEvolved = (start < goal && currentValue > start && currentValue);
+    const stabilizeExceeding = (start === goal && currentValue > start && currentValue > goal);
+    const stabilize = (start === goal && currentValue === goal && start === currentValue);
+    const stabilizeDecreased = (current < start && goal == start);
+    const isGoalDecreased = start > goal && currentValue == goal;
+    const isGoalIncrease = start < goal && currentValue > start && currentValue == goal;
+    // Cálculo do progresso
+    const progressPercentage = useMemo(() => {
+        let percentage;
+        if (start < goal) {
+            percentage = ((currentValue - start) / (goal - start)) * 100;
+        }
+        else {
+            percentage = ((start - currentValue) / (start - goal)) * 100;
+        }
+        return Math.min(Math.max(Math.abs(percentage), 0), 100);
+    }, [currentValue, start, goal]);
+    const positions = useMemo(() => {
+        // reachedGoalIncrease
+        if (start < goal && currentValue > start && currentValue == goal)
+            return {
+                start: 0,
+                current: 100,
+                goal: 100,
+                barRef: 'goal',
+                currentVariant: CurrentVariant?.Normal,
+                message: MESSAGES?.reachedGoal,
+                currentTextInit: MESSAGES?.currentTextInit,
+                TextoGoalDefault: MESSAGES?.TextoGoalDefault
+            };
+        // reachedGoalDecreased
+        if (start > goal && currentValue == goal)
+            return {
+                start: 0,
+                current: 100,
+                goal: 100,
+                barRef: 'goal',
+                currentVariant: CurrentVariant?.Normal,
+                message: MESSAGES?.reachedGoal,
+                currentTextInit: MESSAGES?.currentTextInit,
+                TextoGoalDefault: MESSAGES?.TextoGoalDefault
+            };
+        // exceededTargetIncrease
+        if (start < goal && currentValue > start && currentValue > goal)
+            return {
+                start: 0,
+                current: 100,
+                goal: toRange(start, goal, currentValue),
+                barRef: 'current',
+                currentVariant: CurrentVariant?.Star,
+                message: MESSAGES?.progressExceeded,
+                currenText: MESSAGES?.currentTextResult,
+                currentTextInit: MESSAGES?.currentTextInit,
+                TextoGoalDefault: MESSAGES?.TextoGoalDefault
+            };
+        //stabilizeExceeding
+        if (start === goal && currentValue > start)
+            return {
+                start: 0,
+                current: 100,
+                goal: 14,
+                barRef: 'current',
+                currentVariant: CurrentVariant?.Star,
+                message: MESSAGES?.progressExceeded,
+                currenText: MESSAGES?.currentTextResult,
+                stabilizeExceedingText: MESSAGES?.stabilizeExceedingText
+            };
+        //stabilize
+        if (start === goal && currentValue === goal && start === currentValue)
+            return {
+                start: 0,
+                current: 100,
+                goal: 100,
+                barRef: 'current',
+                currentVariant: CurrentVariant?.Star,
+                message: MESSAGES?.reachedGoal,
+                currentTextInit: MESSAGES?.currentTextInit,
+                textGoal: MESSAGES.textGoal
+            };
+        if (start === goal && currentValue < start)
+            return {
+                start: 100,
+                current: 0,
+                goal: 100,
+                barRef: 'start',
+                currentVariant: CurrentVariant?.Warning,
+                message: MESSAGES?.progressNoGoal,
+                currenText: MESSAGES?.currentTextResult,
+                TextoGoalDefault: MESSAGES?.stabilizeExceedingText
+            };
+        // exceededTargetDecreased
+        if (start > goal && currentValue < goal)
+            return {
+                start: 0,
+                current: 100,
+                goal: toRange(start, currentValue, goal),
+                barRef: 'current',
+                currentVariant: CurrentVariant?.Star,
+                message: MESSAGES?.progressExceeded,
+                currenText: MESSAGES?.currentTextResult,
+                currentTextInit: MESSAGES?.currentTextInit,
+                TextoGoalDefault: MESSAGES?.TextoGoalDefault
+            };
+        // GrowingWithoutReachingGoal
+        if (start < goal && currentValue > start && currentValue < goal)
+            return {
+                start: 0,
+                current: toRange(start, currentValue, goal),
+                goal: 100,
+                barRef: 'current',
+                currentVariant: CurrentVariant?.Normal,
+                message: MESSAGES?.progressImproved,
+                currenText: MESSAGES?.currentTextResult,
+                currentTextInit: MESSAGES?.currentTextInit,
+                TextoGoalDefault: MESSAGES?.TextoGoalDefault
+            };
+        // DecreasingWithoutGoal
+        if (start > goal && currentValue > goal && currentValue < start)
+            return {
+                start: 0,
+                current: toRange(start, goal, currentValue),
+                goal: 100,
+                barRef: 'current',
+                currentVariant: CurrentVariant?.Normal,
+                message: MESSAGES?.progressImproved,
+                currenText: MESSAGES?.currentTextResult,
+                currentTextInit: MESSAGES?.currentTextInit,
+                TextoGoalDefault: MESSAGES?.TextoGoalDefault
+            };
+        // noResultsIncrease
+        if (start < goal && currentValue == start)
+            return {
+                start: 0,
+                current: 0,
+                goal: 100,
+                barRef: 'current',
+                currentVariant: CurrentVariant?.Warning,
+                message: MESSAGES?.progressNoResults,
+                currenText: MESSAGES?.currentTextInitAndResult,
+                TextoGoalDefault: MESSAGES?.TextoGoalDefault
+            };
+        // noResultsDecreased
+        if (start > goal && currentValue == start)
+            return {
+                start: 0,
+                current: 0,
+                goal: 100,
+                bar: 'current',
+                currentVariant: CurrentVariant?.Warning,
+                message: MESSAGES?.progressNoResults,
+                currenText: MESSAGES?.currentTextInitAndResult,
+                TextoGoalDefault: MESSAGES?.TextoGoalDefault
+            };
+        // noGoalIncrease
+        if (start < goal && currentValue < start)
+            return {
+                start: toRange(currentValue, goal, start),
+                current: 0,
+                goal: 100,
+                barRef: 'start',
+                currentVariant: CurrentVariant?.Warning,
+                message: MESSAGES?.progressNoGoal,
+                currenText: MESSAGES?.currentTextResult,
+                currentTextInit: MESSAGES?.currentTextInit,
+                TextoGoalDefault: MESSAGES?.TextoGoalDefault
+            };
+        // noGoalDecreased
+        if (start > goal && currentValue > start)
+            return {
+                start: toRange(currentValue, goal, start),
+                current: 0,
+                goal: 100,
+                barRef: 'start',
+                currentVariant: CurrentVariant?.Warning,
+                message: MESSAGES?.progressNoGoal,
+                currenText: MESSAGES?.currentTextResult,
+                currentTextInit: MESSAGES?.currentTextInit,
+                TextoGoalDefault: MESSAGES?.TextoGoalDefault
+            };
+    }, [start, goal, currentValue]);
+    const isGoalExceeded = useMemo(() => positions?.currentVariant == CurrentVariant?.Star, [positions]);
+    return {
+        progressPercentage,
+        currentValue,
+        endValue,
+        isGoalReached,
+        isGoalExceeded,
+        isNoGoal,
+        positions,
+        noGoal,
+        noResult,
+        resultEvolved,
+        stabilizeExceeding,
+        stabilizeDecreased,
+        stabilize,
+        isGoalDecreased,
+        isGoalIncrease
+    };
+};
+
+export { CurrentVariant, useProgressGoalBar };

package/dist/esm/src/components/DS/resourceInfoDrop/index.js

@@ -0,0 +1,53 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { useRef, useState, useEffect } from 'react';
+import { Dropdown, WrapperDropdownButton, OrnamentInfo, OrnamentInfoIntern, DropdownButton, WrapperExpandButton, WrapperContent, ItemContent, ItemContentLabel } from './styles.js';
+import { ArrrowExpandDropdown } from '../../../shared/icons.js';
+import TargetIcon from '../../../../public/img/TargetIcon.png.js';
+
+const ResourceInfoDrop = ({ label, isOpen, onOpen, onClose, options, enablePulse, intervalPulse }) => {
+    const wrapperRef = useRef(null);
+    const [isOpenDrop, setIsOpenDrop] = useState(false);
+    const [isPulsing, setIsPulsing] = useState(false);
+    useEffect(() => {
+        setIsOpenDrop(isOpen);
+        const intervalId = setInterval(() => {
+            setIsPulsing(true);
+            setTimeout(() => setIsPulsing(false), 1500);
+        }, intervalPulse ?? 120000);
+        return () => clearInterval(intervalId);
+    }, [isOpen]);
+    const [enableTrackChange, setEnableTrackChange] = useState(false);
+    useEffect(() => {
+        if (enableTrackChange) {
+            if (isOpenDrop) {
+                onOpen?.();
+            }
+            else {
+                onClose?.();
+            }
+        }
+        else {
+            setTimeout(() => {
+                setEnableTrackChange(true);
+            }, 2000);
+        }
+    }, [isOpenDrop]);
+    const toggleDropdown = () => {
+        setIsOpenDrop(!isOpenDrop);
+    };
+    useEffect(() => {
+        function handleClickOutside(event) {
+            if (wrapperRef.current && !wrapperRef.current.contains(event.target) && isOpenDrop)
+                setIsOpenDrop(false);
+        }
+        document.addEventListener('mousedown', handleClickOutside);
+        return () => {
+            document.removeEventListener('mousedown', handleClickOutside);
+        };
+    }, [wrapperRef, isOpenDrop]);
+    return (jsxs(Dropdown, { ref: wrapperRef, onClick: toggleDropdown, children: [jsxs(WrapperDropdownButton, { isPulsing: enablePulse && isPulsing, children: [jsx(OrnamentInfo, { children: jsx(OrnamentInfoIntern, { children: jsx("img", { src: TargetIcon, alt: '' }) }) }), jsxs(DropdownButton, { children: [label, jsx(WrapperExpandButton, { isExpanded: isOpenDrop, children: jsx(ArrrowExpandDropdown, { stroke: "#fff", strokeWidth: "1.3" }) })] })] }), jsx(WrapperContent, { isOpen: isOpenDrop, children: options?.map((item, index) => {
+                    return (jsx(ItemContent, { onClick: () => item?.onClick?.(item?.id), children: jsxs(ItemContentLabel, { isLastItem: options?.length - 1 == index, children: [item.startWithIcon, " ", item.label, " ", item.endWithIcon] }) }, item.id));
+                }) })] }));
+};
+
+export { ResourceInfoDrop as default };

package/dist/esm/src/components/DS/resourceInfoDrop/styles.js

@@ -0,0 +1,142 @@
+import styled, { keyframes, css } from 'styled-components';
+
+const pulseAnimation = keyframes `
+  0% {
+    transform: scale(1);
+    animation-timing-function: ease-in;
+  }
+  50% {
+    transform: scale(1.1);
+    animation-timing-function: ease-in;
+  }
+  100% {
+    transform: scale(1);
+    animation-timing-function: ease-out;
+  }
+`;
+const Dropdown = styled.div `
+  cursor: pointer;
+  width: fit-content;
+  height: fit-content;
+`;
+const WrapperDropdownButton = styled.div `
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+  user-select: none;
+
+  ${props => props.isPulsing && css `
+    animation: ${pulseAnimation} 0.7s ease-in-out;
+  `}
+`;
+const OrnamentInfo = styled.div `
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  width: 36px;
+  height: 36px;
+  min-width: 36px;
+  min-height: 36px;
+  border-radius: 50%;
+  background-color: #2d7781;
+  margin-right: -8px;
+  z-index: 2;
+`;
+const OrnamentInfoIntern = styled.div `
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  background-color: #E78123;
+  width: 30px;
+  height: 30px;
+  border-radius: 50%;
+  z-index: 3;
+`;
+const DropdownButton = styled.div `
+  height: 28px;
+  white-space: nowrap;
+  padding: 4px 12px 4px 16px;
+  border-radius: 0px 16px 16px 0px;
+  background-color: #318894;
+
+  font-family: PT Sans;
+  font-size: 16px;
+  font-weight: 400;
+  line-height: 20.7px;
+  text-align: left;
+  color: #fff;
+  cursor: pointer;
+
+  display: flex;
+  flex-direction: row;
+  gap: 12px;
+
+`;
+const WrapperExpandButton = styled.div `
+  display: flex;
+  cursor: pointer;
+  justify-content: center;
+  align-items: center;
+  transition: transform 0.3s ease-in-out;
+  transform: ${({ isExpanded }) => (isExpanded ? 'rotate(180deg)' : 'rotate(0deg)')} ;
+`;
+const WrapperContent = styled.div `
+  position: absolute;
+
+  width: 266px;
+  border-radius: 8px;
+  height: fit-content;
+  background-color: #FFF;
+  
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+
+  margin-top: 4px;
+
+  background-color: #FFFFFF;
+  box-shadow: 0px 5px 15px 0px #00000040;
+
+
+  max-height: ${props => props.isOpen ? '1000px' : '0'};
+  opacity: ${props => props.isOpen ? 1 : 0};
+  overflow: hidden;
+  transition: max-height 0.8s ease, opacity 0.2s ease;
+`;
+const ItemContent = styled.div `
+  display: flex;
+  align-items: center;
+  width: 100%;
+  height: fit-content;
+
+  background-color: #FFF;
+  transition: background-color 0.3s ease;
+  padding: 2px 8px 0px 8px;
+
+  &:hover {
+    background-color: #f0f0f0;
+  }
+`;
+const ItemContentLabel = styled.div `
+  align-items: center;
+  display: flex;
+  width: 100%;
+  height: 40px;
+  padding: 10px 4px 10px 4px;
+  gap: 10px;
+
+  font-family: PT Sans;
+  font-size: 14px;
+  font-weight: 400;
+  line-height: 18.12px;
+  text-align: left;
+
+  user-select: none;
+  cursor: pointer;
+
+  border-bottom: 1px solid ${({ isLastItem }) => isLastItem ? `transparent` : `#E0E0E0`};
+
+`;
+
+export { Dropdown, DropdownButton, ItemContent, ItemContentLabel, OrnamentInfo, OrnamentInfoIntern, WrapperContent, WrapperDropdownButton, WrapperExpandButton };

package/dist/esm/src/components/DS/resultFilterTabs/dropDownResult/index.js

@@ -0,0 +1,20 @@
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { Popover } from '@mui/material';
+import { ContainerDropdown, DropdownRow } from './styles.js';
+
+function DropdownResult({ isOpen, anchor, onClose, ResultList, onClickResultList }) {
+    const render = () => {
+        return (ResultList.map((item, index) => {
+            return (jsx(DropdownRow, { onClick: () => onClickResultList(item), children: jsxs("p", { children: [item.name, " ", item.version] }) }, index));
+        }));
+    };
+    return (jsx(Popover, { open: isOpen, onClose: onClose, anchorEl: anchor, anchorOrigin: {
+            horizontal: 'right',
+            vertical: 'bottom'
+        }, transformOrigin: {
+            horizontal: 'right',
+            vertical: 'top'
+        }, children: jsx(ContainerDropdown, { children: render() }) }));
+}
+
+export { DropdownResult as default };

package/dist/esm/src/components/DS/resultFilterTabs/dropDownResult/styles.js

@@ -0,0 +1,38 @@
+import styled from 'styled-components';
+
+const ContainerDropdown = styled('div') `
+    display: flex;
+    flex-direction: column;
+    padding: 4px 8px;
+    border-radius: 8px;
+    box-shadow: 0px 5px 15px 0px #00000040;
+    background-color: #FFFFFF;
+    width: 300px;
+`;
+const DropdownRow = styled('div') `
+    padding: 10px 4px;
+    border-top: 1px solid #E0E0E0;
+    cursor: pointer;
+
+    p {
+        font-family: 'PT Sans';
+        font-size: 16px;
+        line-height: 1.1;
+        font-weight: 400;
+        color: #222222;
+        white-space: nowrap;
+        text-overflow: ellipsis;
+        overflow: hidden
+    }
+
+    :first-child {
+        border: none;
+    }
+
+    :hover {
+        background-color: #ebeded;
+    }
+    
+`;
+
+export { ContainerDropdown, DropdownRow };

package/dist/esm/src/components/DS/resultFilterTabs/index.js

@@ -0,0 +1,162 @@
+import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
+import { useState, useRef, useMemo, useEffect } from 'react';
+import { Tab, Container, Tabs, WrapperTabsResultSelect, WrapperSelectIcon, Content, Info, inputIndicator, WrapperFieldValueDate, Menu } from './resultFilterTabsStyles.js';
+import MenuMore from '../../menu-more/index.js';
+import { ArrrowExpandDropdown, CalendarIcon, EditHipoteses, TrashHipoteses } from '../../../shared/icons.js';
+import DropdownResult from './dropDownResult/index.js';
+import Tooltip from '../tooltip/index.js';
+import { DatePicker } from 'rsuite';
+import './rsuite.min.css.js';
+
+const ResultFilterTabs = ({ results, onTabChange, onDelete, onEdit, tabLimit }) => {
+    const [activeTab, setActiveTab] = useState(0); // Controla a tab ativa
+    const [isEditing, setIsEditing] = useState(false);
+    const [newValue, setNewValue] = useState(results[0]?.value_indicator);
+    const [newDate, setNewDate] = useState(results[0]?.expectation_date);
+    const [filteredResults, setFilteredResults] = useState([]);
+    const [hiddenTabs, setHiddenTabs] = useState([]);
+    const [isDropdownOpen, setIsDropdownOpen] = useState(false);
+    const editContainerRef = useRef(null); // Referência para detectar cliques fora
+    const [anchor, setAnchor] = useState(null);
+    const [dateValue, setDateValue] = useState(null);
+    const [datePickerOpen, setDatePickerOpen] = useState(false);
+    const toggleDropdown = () => {
+        setIsDropdownOpen(!isDropdownOpen);
+    };
+    // Função para fechar o dropdown
+    const closeDropdown = () => {
+        setIsDropdownOpen(false);
+    };
+    const handleTabClick = (index, version) => {
+        if (isEditing) {
+            handleEdit(); // Salva se estiver no modo de edição
+        }
+        setActiveTab(index);
+        setNewValue(results[index]?.value_indicator);
+        setNewDate(results[index]?.expectation_date);
+        setIsEditing(false); // Sai do modo de edição ao mudar a aba
+        if (onTabChange) {
+            onTabChange(version);
+        }
+    };
+    const handleDelete = () => {
+        onDelete();
+    };
+    const canShowDropdown = useMemo(() => {
+        if (tabLimit)
+            return results.length > tabLimit;
+        return false;
+    }, [tabLimit, results]);
+    const changeFilteredResults = (activeTabIndex) => {
+        if (canShowDropdown) {
+            let updatedResults = filteredResults.length ? [...filteredResults] : [...results.slice(0, tabLimit)];
+            // Verifica se o item clicado não está nos resultados filtrados
+            const selectedResult = results[activeTabIndex];
+            const isSelectedResultInFiltered = updatedResults.some((i) => i.version === selectedResult.version);
+            if (!isSelectedResultInFiltered) {
+                // Insere o item clicado no início e remove o último
+                updatedResults = [selectedResult, ...updatedResults.slice(0, tabLimit - 1)];
+                setActiveTab(0); // Isso faz com que a primeira aba (o item clicado) seja visualmente selecionada
+            }
+            if (onTabChange && activeTab !== activeTabIndex) {
+                onTabChange(activeTabIndex);
+            }
+            setHiddenTabs(results.filter(i => updatedResults.every(a => a.version !== i.version)));
+            setFilteredResults(updatedResults);
+            // Atualiza a aba ativa para a primeira posição
+        }
+        else {
+            // Se o dropdown não for exibido, retorna a lista completa
+            setFilteredResults(results);
+            // Atualiza a aba ativa para a aba original clicada
+            setActiveTab(activeTabIndex);
+        }
+    };
+    const tabs = useMemo(() => {
+        return (jsx(Fragment, { children: filteredResults?.map((result, index) => (jsxs(Tab, { "$isActive": activeTab === index, onClick: () => handleTabClick(index, result?.version), children: [result.name, " ", result.name === 'Resultado' ? result?.version : result?.version - 1] }, index))) }));
+    }, [filteredResults, activeTab]);
+    const handleEdit = () => {
+        if (!isEditing)
+            return;
+        const payload = {
+            name: results[activeTab].name,
+            version: results[activeTab].version,
+            value_indicator: newValue,
+            expectation_date: newDate
+        };
+        if (onEdit)
+            onEdit(payload);
+    };
+    // Função para iniciar a edição com clique duplo
+    const handleDoubleClick = () => {
+        if (filteredResults[activeTab].editable) {
+            setIsEditing(true);
+        }
+    };
+    useEffect(() => {
+        changeFilteredResults(0);
+    }, []);
+    useEffect(() => {
+        const handleClickOutside = (event) => {
+            if (editContainerRef.current && !editContainerRef.current.contains(event.target) && !datePickerOpen) {
+                if (isEditing) {
+                    handleEdit(); // Salva os dados ao clicar fora do campo de edição
+                    setIsEditing(false);
+                }
+            }
+        };
+        document.addEventListener('mousedown', handleClickOutside);
+        return () => {
+            document.removeEventListener('mousedown', handleClickOutside);
+        };
+    }, [isEditing, newValue, newDate, datePickerOpen]);
+    useEffect(() => {
+        if (!dateValue) {
+            let parts = newDate.split('/');
+            let dia = parts[0];
+            let mes = parts[1];
+            let ano = parts[2];
+            if (ano.length === 2) {
+                ano = '20' + ano;
+            }
+            const dateFixed = new Date(parseInt(ano), parseInt(mes) - 1, parseInt(dia));
+            setDateValue(dateFixed);
+        }
+    }, [newDate]);
+    return (jsxs(Container, { children: [jsxs(Tabs, { children: [jsx("div", { style: { display: 'flex' }, children: tabs }), canShowDropdown && (jsx(Tooltip, { content: "Ver todos os Resultados", direction: "bottom", delay: 200, style: { textAlign: 'center' }, children: jsxs(WrapperTabsResultSelect, { "$activeSelect": isDropdownOpen, onClick: (event) => {
+                                setAnchor(event?.currentTarget);
+                                toggleDropdown();
+                            }, children: [jsxs("p", { children: ["Mais ", hiddenTabs.length] }), jsx(WrapperSelectIcon, { "$isOpenSelect": isDropdownOpen, children: jsx(ArrrowExpandDropdown, {}) })] }) }))] }), jsxs(Content, { ref: editContainerRef, onDoubleClick: handleDoubleClick, children: [jsxs(Info, { children: [jsxs("p", { children: ["Valor a ser atingido:", ' ', isEditing ? (jsx(inputIndicator, { type: "text", value: newValue, onChange: (e) => {
+                                            const maskedValue = e?.target?.value;
+                                            // Aceita números, ponto e vírgula
+                                            const numericValue = maskedValue.replace(/[^\d.,]/g, '');
+                                            setNewValue(numericValue);
+                                        } })) : (jsx("span", { children: filteredResults[activeTab]?.value_indicator }))] }), jsxs("p", { children: ["Data para atingir o resultado:", ' ', isEditing ? (jsx(WrapperFieldValueDate, { children: jsx(DatePicker, { value: dateValue, format: "dd/MM/yyyy", onOpen: () => setDatePickerOpen(true), onChange: (e) => {
+                                                setDateValue(e);
+                                                setNewDate(e.toLocaleDateString());
+                                                setDatePickerOpen(false);
+                                            }, onClose: () => setDatePickerOpen(false), placeholder: "DD/MM/AAAA", oneTap: true, disabled: false, caretAs: CalendarIcon }) })) : (jsx("span", { children: filteredResults[activeTab]?.expectation_date }))] })] }), jsx(Menu, { children: filteredResults[activeTab]?.editable && (jsx(Menu, { children: jsx(MenuMore, { options: [
+                                    {
+                                        description: 'Editar',
+                                        onClick: () => {
+                                            setIsEditing(true);
+                                        },
+                                        color: '#222222',
+                                        startIcon: jsx(EditHipoteses, {})
+                                    },
+                                    {
+                                        description: 'Excluir',
+                                        onClick: () => {
+                                            handleDelete();
+                                        },
+                                        color: '#C00F00',
+                                        startIcon: jsx(TrashHipoteses, {})
+                                    }
+                                ], isContainerOptions: true, closeAfterClick: true }) })) })] }), jsx(DropdownResult, { anchor: anchor, isOpen: isDropdownOpen, onClose: closeDropdown, ResultList: hiddenTabs, maxTabs: tabLimit, onClickResultList: (item) => {
+                    const selectedVersion = item.version;
+                    const selectedIndex = results.findIndex((result) => result.version === selectedVersion);
+                    changeFilteredResults(selectedIndex);
+                } })] }));
+};
+
+export { ResultFilterTabs };