analytica-frontend-lib 1.2.35 → 1.2.37

package/dist/ActivityFilters/index.js

@@ -34,7 +34,7 @@ __export(ActivityFilters_exports, {
   ActivityFiltersPopover: () => ActivityFiltersPopover
 });
 module.exports = __toCommonJS(ActivityFilters_exports);
-var import_react13 = require("react");
+var import_react14 = require("react");
 
 // src/utils/utils.ts
 var import_clsx = require("clsx");
@@ -4584,9 +4584,503 @@ var questionTypeLabels = {
   ["PREENCHER" /* PREENCHER */]: "Preencher Lacunas"
 };
 
+// src/hooks/useActivityFiltersData.ts
+var import_react13 = require("react");
+var mapQuestionTypeToEnum = (type) => {
+  const upperType = type.toUpperCase();
+  const typeMap = {
+    ALTERNATIVA: "ALTERNATIVA" /* ALTERNATIVA */,
+    DISSERTATIVA: "DISSERTATIVA" /* DISSERTATIVA */,
+    MULTIPLA_ESCOLHA: "MULTIPLA_ESCOLHA" /* MULTIPLA_ESCOLHA */,
+    VERDADEIRO_FALSO: "VERDADEIRO_FALSO" /* VERDADEIRO_FALSO */,
+    IMAGEM: "IMAGEM" /* IMAGEM */,
+    LIGAR_PONTOS: "LIGAR_PONTOS" /* LIGAR_PONTOS */,
+    PREENCHER: "PREENCHER" /* PREENCHER */
+  };
+  return typeMap[upperType] || null;
+};
+var areCategoriesSame = (prev, current) => {
+  if (prev.length !== current.length) return false;
+  return current.every((category) => {
+    const prevCategory = prev.find((c) => c.key === category.key);
+    if (!prevCategory) return false;
+    const prevIds = (prevCategory.itens || []).map(
+      (item) => item.id
+    );
+    const currentIds = (category.itens || []).map(
+      (item) => item.id
+    );
+    if (prevIds.length !== currentIds.length) return false;
+    return currentIds.every((id) => prevIds.includes(id));
+  });
+};
+var mergeCategoriesWithSelection = (prev, current) => {
+  return current.map((category) => {
+    const prevCategory = prev.find((c) => c.key === category.key);
+    if (!prevCategory) {
+      return category;
+    }
+    const validSelectedIds = (prevCategory.selectedIds || []).filter(
+      (id) => category.itens?.some((item) => item.id === id)
+    );
+    return {
+      ...category,
+      selectedIds: validSelectedIds
+    };
+  });
+};
+var mapSelectedNames = (ids, items) => {
+  return ids.map((id) => {
+    const item = items.find((t) => t.id === id);
+    return item ? item.name : null;
+  }).filter((name) => name !== null);
+};
+var useActivityFiltersDataImpl = (apiClient, options) => {
+  const { selectedSubjects, institutionId } = options;
+  const [banksState, setBanksState] = (0, import_react13.useState)({
+    banks: [],
+    bankYears: [],
+    loading: false,
+    error: null
+  });
+  const loadBanks = (0, import_react13.useCallback)(async () => {
+    setBanksState((prev) => ({ ...prev, loading: true, error: null }));
+    try {
+      const response = await apiClient.get(
+        "/questions/exam-institutions"
+      );
+      const banksMap = /* @__PURE__ */ new Map();
+      const bankYearsArray = [];
+      for (const item of response.data.data) {
+        if (!item.questionBankName) continue;
+        const existingBank = banksMap.get(item.questionBankName);
+        if (existingBank) {
+          if (!existingBank.years.includes(item.year)) {
+            existingBank.years.push(item.year);
+          }
+          existingBank.questionsCount += item.questionsCount;
+        } else {
+          banksMap.set(item.questionBankName, {
+            id: item.questionBankName,
+            name: item.questionBankName,
+            examInstitution: item.questionBankName,
+            years: [item.year],
+            questionsCount: item.questionsCount
+          });
+        }
+        bankYearsArray.push({
+          id: `${item.questionBankYearId}-${item.questionBankName}`,
+          name: item.year,
+          bankId: item.questionBankName
+        });
+      }
+      const banks = Array.from(banksMap.values()).map((bank) => ({
+        id: bank.id,
+        name: bank.name,
+        examInstitution: bank.examInstitution
+      }));
+      setBanksState({
+        banks,
+        bankYears: bankYearsArray,
+        loading: false,
+        error: null
+      });
+    } catch (error) {
+      console.error("Erro ao carregar bancas de vestibular:", error);
+      setBanksState((prev) => ({
+        ...prev,
+        loading: false,
+        error: "Erro ao carregar bancas de vestibular"
+      }));
+    }
+  }, [apiClient]);
+  const [areasState, setAreasState] = (0, import_react13.useState)({
+    knowledgeAreas: [],
+    loading: false,
+    error: null
+  });
+  const loadKnowledgeAreas = (0, import_react13.useCallback)(async () => {
+    setAreasState((prev) => ({ ...prev, loading: true, error: null }));
+    try {
+      const response = await apiClient.get(
+        "/knowledge/subjects"
+      );
+      setAreasState({
+        knowledgeAreas: response.data.data,
+        loading: false,
+        error: null
+      });
+    } catch (error) {
+      console.error("Erro ao carregar \xE1reas de conhecimento:", error);
+      setAreasState((prev) => ({
+        ...prev,
+        loading: false,
+        error: "Erro ao carregar \xE1reas de conhecimento"
+      }));
+    }
+  }, [apiClient]);
+  const [questionTypesState, setQuestionTypesState] = (0, import_react13.useState)({
+    questionTypes: [],
+    loading: false,
+    error: null
+  });
+  const loadQuestionTypes = (0, import_react13.useCallback)(async () => {
+    if (!institutionId) {
+      setQuestionTypesState((prev) => ({
+        ...prev,
+        questionTypes: [],
+        loading: false,
+        error: null
+      }));
+      return;
+    }
+    setQuestionTypesState((prev) => ({
+      ...prev,
+      loading: true,
+      error: null
+    }));
+    try {
+      const response = await apiClient.get(
+        `/institutions/${institutionId}/question-types`
+      );
+      const mappedTypes = response.data.data.questionTypes.map(mapQuestionTypeToEnum).filter((type) => type !== null);
+      setQuestionTypesState({
+        questionTypes: mappedTypes,
+        loading: false,
+        error: null
+      });
+    } catch (error) {
+      console.error("Erro ao carregar tipos de quest\xF5es:", error);
+      setQuestionTypesState((prev) => ({
+        ...prev,
+        loading: false,
+        error: "Erro ao carregar tipos de quest\xF5es"
+      }));
+    }
+  }, [apiClient, institutionId]);
+  const [knowledgeStructure, setKnowledgeStructure] = (0, import_react13.useState)({
+    topics: [],
+    subtopics: [],
+    contents: [],
+    loading: false,
+    error: null
+  });
+  const [knowledgeCategories, setKnowledgeCategories] = (0, import_react13.useState)([]);
+  const previousSubjectsRef = (0, import_react13.useRef)(null);
+  const loadTopics = (0, import_react13.useCallback)(
+    async (subjectIds) => {
+      if (subjectIds.length === 0) {
+        setKnowledgeStructure({
+          topics: [],
+          subtopics: [],
+          contents: [],
+          loading: false,
+          error: null
+        });
+        setKnowledgeCategories([]);
+        return;
+      }
+      setKnowledgeStructure((prev) => ({
+        ...prev,
+        loading: true,
+        error: null
+      }));
+      try {
+        const response = await apiClient.post(
+          "/knowledge/topics",
+          { subjectIds }
+        );
+        const topics = response.data.data.map((topic) => ({
+          id: topic.id,
+          name: topic.name
+        }));
+        setKnowledgeStructure((prev) => ({
+          ...prev,
+          topics,
+          subtopics: [],
+          contents: [],
+          loading: false,
+          error: null
+        }));
+      } catch (error) {
+        console.error("Erro ao carregar temas:", error);
+        setKnowledgeStructure((prev) => ({
+          ...prev,
+          topics: [],
+          subtopics: [],
+          contents: [],
+          loading: false,
+          error: "Erro ao carregar temas"
+        }));
+      }
+    },
+    [apiClient]
+  );
+  const loadSubtopics = (0, import_react13.useCallback)(
+    async (topicIds, options2 = {}) => {
+      const { forceApi = false } = options2;
+      if (topicIds.length === 0 && !forceApi) {
+        setKnowledgeStructure((prev) => ({
+          ...prev,
+          subtopics: [],
+          contents: [],
+          loading: false,
+          error: null
+        }));
+        return;
+      }
+      setKnowledgeStructure((prev) => ({
+        ...prev,
+        loading: topicIds.length > 0,
+        error: null
+      }));
+      try {
+        const response = await apiClient.post(
+          "/knowledge/subtopics",
+          { topicIds }
+        );
+        const subtopics = response.data.data.map(
+          (subtopic) => ({
+            id: subtopic.id,
+            name: subtopic.name,
+            topicId: subtopic.topicId || topicIds[0]
+          })
+        );
+        setKnowledgeStructure((prev) => ({
+          ...prev,
+          subtopics,
+          contents: [],
+          loading: false,
+          error: null
+        }));
+      } catch (error) {
+        console.error("Erro ao carregar subtemas:", error);
+        setKnowledgeStructure((prev) => ({
+          ...prev,
+          subtopics: [],
+          contents: [],
+          loading: false,
+          error: "Erro ao carregar subtemas"
+        }));
+      }
+    },
+    [apiClient]
+  );
+  const loadContents = (0, import_react13.useCallback)(
+    async (subtopicIds) => {
+      if (subtopicIds.length === 0) {
+        setKnowledgeStructure((prev) => ({
+          ...prev,
+          contents: [],
+          loading: false,
+          error: null
+        }));
+        return;
+      }
+      setKnowledgeStructure((prev) => ({
+        ...prev,
+        loading: true,
+        error: null
+      }));
+      try {
+        const response = await apiClient.post(
+          "/knowledge/contents",
+          { subtopicIds }
+        );
+        const contents = response.data.data.map(
+          (content) => ({
+            id: content.id,
+            name: content.name,
+            subtopicId: content.subtopicId || subtopicIds[0]
+          })
+        );
+        setKnowledgeStructure((prev) => ({
+          ...prev,
+          contents,
+          loading: false,
+          error: null
+        }));
+      } catch (error) {
+        console.error("Erro ao carregar conte\xFAdos:", error);
+        setKnowledgeStructure((prev) => ({
+          ...prev,
+          contents: [],
+          loading: false,
+          error: "Erro ao carregar conte\xFAdos"
+        }));
+      }
+    },
+    [apiClient]
+  );
+  (0, import_react13.useEffect)(() => {
+    const previousSubjects = previousSubjectsRef.current;
+    const subjectsChanged = !previousSubjects || previousSubjects.length !== selectedSubjects.length || selectedSubjects.some((id, index) => id !== previousSubjects[index]);
+    if (!subjectsChanged) return;
+    previousSubjectsRef.current = selectedSubjects;
+    if (selectedSubjects.length > 0) {
+      loadTopics(selectedSubjects);
+      return;
+    }
+    setKnowledgeStructure({
+      topics: [],
+      subtopics: [],
+      contents: [],
+      loading: false,
+      error: null
+    });
+    setKnowledgeCategories([]);
+  }, [selectedSubjects, loadTopics]);
+  const handleCategoriesChange = (0, import_react13.useCallback)(
+    (updatedCategories) => {
+      const isFirstChange = knowledgeCategories.length === 0;
+      const currentTemaCategory = knowledgeCategories.find(
+        (c) => c.key === "tema"
+      );
+      const currentSubtemaCategory = knowledgeCategories.find(
+        (c) => c.key === "subtema"
+      );
+      const currentSelectedTopicIds = currentTemaCategory?.selectedIds || [];
+      const currentSelectedSubtopicIds = currentSubtemaCategory?.selectedIds || [];
+      const temaCategory = updatedCategories.find((c) => c.key === "tema");
+      const selectedTopicIds = temaCategory?.selectedIds || [];
+      const subtemaCategory = updatedCategories.find(
+        (c) => c.key === "subtema"
+      );
+      const selectedSubtopicIds = subtemaCategory?.selectedIds || [];
+      setKnowledgeCategories(updatedCategories);
+      const topicIdsChanged = isFirstChange || currentSelectedTopicIds.length !== selectedTopicIds.length || currentSelectedTopicIds.some(
+        (id) => !selectedTopicIds.includes(id)
+      ) || selectedTopicIds.some(
+        (id) => !currentSelectedTopicIds.includes(id)
+      );
+      if (topicIdsChanged) {
+        loadSubtopics(selectedTopicIds, {
+          forceApi: selectedTopicIds.length === 0
+        });
+      }
+      const subtopicIdsChanged = isFirstChange || currentSelectedSubtopicIds.length !== selectedSubtopicIds.length || currentSelectedSubtopicIds.some(
+        (id) => !selectedSubtopicIds.includes(id)
+      ) || selectedSubtopicIds.some(
+        (id) => !currentSelectedSubtopicIds.includes(id)
+      );
+      if (subtopicIdsChanged) {
+        if (selectedSubtopicIds.length > 0) {
+          loadContents(selectedSubtopicIds);
+        } else {
+          loadContents([]);
+        }
+      }
+    },
+    [knowledgeCategories, loadSubtopics, loadContents]
+  );
+  (0, import_react13.useEffect)(() => {
+    if (knowledgeStructure.topics.length === 0) {
+      setKnowledgeCategories((prev) => {
+        if (prev.length === 0) {
+          return prev;
+        }
+        return [];
+      });
+      return;
+    }
+    const categories = [
+      {
+        key: "tema",
+        label: "Tema",
+        dependsOn: [],
+        itens: knowledgeStructure.topics,
+        selectedIds: []
+      },
+      {
+        key: "subtema",
+        label: "Subtema",
+        dependsOn: ["tema"],
+        itens: knowledgeStructure.subtopics,
+        filteredBy: [{ key: "tema", internalField: "topicId" }],
+        selectedIds: []
+      },
+      {
+        key: "assunto",
+        label: "Assunto",
+        dependsOn: ["subtema"],
+        itens: knowledgeStructure.contents,
+        filteredBy: [{ key: "subtema", internalField: "subtopicId" }],
+        selectedIds: []
+      }
+    ];
+    setKnowledgeCategories(
+      (prev) => areCategoriesSame(prev, categories) ? prev : mergeCategoriesWithSelection(prev, categories)
+    );
+  }, [
+    selectedSubjects,
+    knowledgeStructure.topics,
+    knowledgeStructure.subtopics,
+    knowledgeStructure.contents
+  ]);
+  const selectedKnowledgeSummary = (0, import_react13.useMemo)(() => {
+    const temaCategory = knowledgeCategories.find((c) => c.key === "tema");
+    const subtemaCategory = knowledgeCategories.find(
+      (c) => c.key === "subtema"
+    );
+    const assuntoCategory = knowledgeCategories.find(
+      (c) => c.key === "assunto"
+    );
+    const selectedTopics = mapSelectedNames(
+      temaCategory?.selectedIds || [],
+      knowledgeStructure.topics
+    );
+    const selectedSubtopics = mapSelectedNames(
+      subtemaCategory?.selectedIds || [],
+      knowledgeStructure.subtopics
+    );
+    const selectedContents = mapSelectedNames(
+      assuntoCategory?.selectedIds || [],
+      knowledgeStructure.contents
+    );
+    return {
+      topics: selectedTopics,
+      subtopics: selectedSubtopics,
+      contents: selectedContents
+    };
+  }, [knowledgeCategories, knowledgeStructure]);
+  const enableSummary = (0, import_react13.useMemo)(() => {
+    return knowledgeStructure.topics.length === 1 || knowledgeStructure.subtopics.length === 1 || knowledgeStructure.contents.length === 1;
+  }, [knowledgeStructure]);
+  return {
+    // Vestibular Banks
+    banks: banksState.banks,
+    bankYears: banksState.bankYears,
+    loadingBanks: banksState.loading,
+    banksError: banksState.error,
+    loadBanks,
+    // Knowledge Areas
+    knowledgeAreas: areasState.knowledgeAreas,
+    loadingSubjects: areasState.loading,
+    subjectsError: areasState.error,
+    loadKnowledgeAreas,
+    // Knowledge Structure
+    knowledgeStructure,
+    knowledgeCategories,
+    handleCategoriesChange,
+    selectedKnowledgeSummary,
+    enableSummary,
+    loadTopics,
+    loadSubtopics,
+    loadContents,
+    // Question Types
+    questionTypes: questionTypesState.questionTypes,
+    loadingQuestionTypes: questionTypesState.loading,
+    questionTypesError: questionTypesState.error,
+    loadQuestionTypes
+  };
+};
+var createUseActivityFiltersData = (apiClient) => {
+  return (options) => useActivityFiltersDataImpl(apiClient, options);
+};
+
 // src/components/ActivityFilters/ActivityFilters.tsx
 var import_jsx_runtime21 = require("react/jsx-runtime");
-var questionTypes = [
+var questionTypesFallback = [
   "ALTERNATIVA" /* ALTERNATIVA */,
   "VERDADEIRO_FALSO" /* VERDADEIRO_FALSO */,
   "DISSERTATIVA" /* DISSERTATIVA */,
@@ -4600,7 +5094,7 @@ var QuestionTypeFilter = ({
   onToggleType,
   allowedQuestionTypes
 }) => {
-  const availableQuestionTypes = allowedQuestionTypes || questionTypes;
+  const availableQuestionTypes = allowedQuestionTypes || questionTypesFallback;
   return /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)("div", { children: [
     /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(Text_default, { size: "sm", weight: "bold", className: "mb-3 block", children: "Tipo de quest\xE3o" }),
     /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("div", { className: "grid grid-cols-2 gap-2", children: availableQuestionTypes.map((questionType) => /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(
@@ -4725,45 +5219,42 @@ var FilterActions = ({
   ] });
 };
 var ActivityFilters = ({
+  apiClient,
   onFiltersChange,
   variant = "default",
-  // Data
-  banks = [],
-  bankYears = [],
-  knowledgeAreas = [],
-  knowledgeStructure = {
-    topics: [],
-    subtopics: [],
-    contents: [],
-    loading: false,
-    error: null
-  },
-  knowledgeCategories = [],
+  institutionId = null,
   // Question types
   allowedQuestionTypes,
-  // Loading states
-  loadingBanks = false,
-  loadingKnowledge: _loadingKnowledge = false,
-  loadingSubjects = false,
-  // Errors
-  banksError = null,
-  subjectsError = null,
-  // Load functions
-  loadBanks,
-  loadKnowledge,
-  loadTopics,
-  loadSubtopics: _loadSubtopics,
-  loadContents: _loadContents,
-  // Handlers
-  handleCategoriesChange,
   // Action buttons
   onClearFilters,
   onApplyFilters
 }) => {
-  const [selectedQuestionTypes, setSelectedQuestionTypes] = (0, import_react13.useState)([]);
-  const [selectedSubject, setSelectedSubject] = (0, import_react13.useState)(null);
-  const prevAllowedQuestionTypesRef = (0, import_react13.useRef)(null);
-  (0, import_react13.useEffect)(() => {
+  const useActivityFiltersData = createUseActivityFiltersData(apiClient);
+  const [selectedQuestionTypes, setSelectedQuestionTypes] = (0, import_react14.useState)([]);
+  const [selectedSubject, setSelectedSubject] = (0, import_react14.useState)(null);
+  const {
+    banks,
+    bankYears,
+    loadingBanks,
+    banksError,
+    knowledgeAreas,
+    loadingSubjects,
+    subjectsError,
+    knowledgeStructure,
+    knowledgeCategories,
+    handleCategoriesChange,
+    loadBanks,
+    loadKnowledgeAreas,
+    loadQuestionTypes,
+    questionTypes,
+    loadingQuestionTypes,
+    questionTypesError
+  } = useActivityFiltersData({
+    selectedSubjects: selectedSubject ? [selectedSubject] : [],
+    institutionId
+  });
+  const prevAllowedQuestionTypesRef = (0, import_react14.useRef)(null);
+  (0, import_react14.useEffect)(() => {
     if (!allowedQuestionTypes || allowedQuestionTypes.length === 0) {
       prevAllowedQuestionTypesRef.current = null;
       return;
@@ -4796,8 +5287,8 @@ var ActivityFilters = ({
       return prev;
     });
   }, [allowedQuestionTypes]);
-  const [bankCategories, setBankCategories] = (0, import_react13.useState)([]);
-  const selectedSubjects = (0, import_react13.useMemo)(
+  const [bankCategories, setBankCategories] = (0, import_react14.useState)([]);
+  const selectedSubjects = (0, import_react14.useMemo)(
     () => selectedSubject ? [selectedSubject] : [],
     [selectedSubject]
   );
@@ -4810,7 +5301,7 @@ var ActivityFilters = ({
   const handleBankCategoriesChange = (updatedCategories) => {
     setBankCategories(updatedCategories);
   };
-  (0, import_react13.useEffect)(() => {
+  (0, import_react14.useEffect)(() => {
     setBankCategories((prevCategories) => {
       const bankCategory = {
         key: "banca",
@@ -4836,37 +5327,42 @@ var ActivityFilters = ({
       return [bankCategory, yearCategory];
     });
   }, [banks, bankYears]);
-  (0, import_react13.useEffect)(() => {
+  (0, import_react14.useEffect)(() => {
     if (loadBanks) {
       loadBanks();
     }
-    if (loadKnowledge) {
-      loadKnowledge();
+    if (loadKnowledgeAreas) {
+      loadKnowledgeAreas();
     }
-  }, [loadBanks, loadKnowledge]);
-  (0, import_react13.useEffect)(() => {
-    if (selectedSubject && loadTopics) {
-      loadTopics([selectedSubject]);
+    if (loadQuestionTypes) {
+      loadQuestionTypes();
+    }
+  }, [loadBanks, loadKnowledgeAreas, loadQuestionTypes, institutionId]);
+  const availableQuestionTypes = (0, import_react14.useMemo)(() => {
+    const source = questionTypes && questionTypes.length > 0 ? questionTypes : questionTypesFallback;
+    if (!allowedQuestionTypes || allowedQuestionTypes.length === 0) {
+      return source;
     }
-  }, [selectedSubject, loadTopics]);
-  const getSelectedKnowledgeIds = (0, import_react13.useCallback)(() => {
+    return source.filter((type) => allowedQuestionTypes.includes(type));
+  }, [questionTypes, allowedQuestionTypes]);
+  const getSelectedKnowledgeIds = (0, import_react14.useCallback)(() => {
     return getSelectedIdsFromCategories(knowledgeCategories, {
       topicIds: "tema",
       subtopicIds: "subtema",
       contentIds: "assunto"
     });
   }, [knowledgeCategories]);
-  const getSelectedBankIds = (0, import_react13.useCallback)(() => {
+  const getSelectedBankIds = (0, import_react14.useCallback)(() => {
     return getSelectedIdsFromCategories(bankCategories, {
       bankIds: "banca",
       yearIds: "ano"
     });
   }, [bankCategories]);
-  const onFiltersChangeRef = (0, import_react13.useRef)(onFiltersChange);
-  (0, import_react13.useEffect)(() => {
+  const onFiltersChangeRef = (0, import_react14.useRef)(onFiltersChange);
+  (0, import_react14.useEffect)(() => {
     onFiltersChangeRef.current = onFiltersChange;
   }, [onFiltersChange]);
-  (0, import_react13.useEffect)(() => {
+  (0, import_react14.useEffect)(() => {
     const knowledgeIds = getSelectedKnowledgeIds();
     const bankIds = getSelectedBankIds();
     const filters = {
@@ -4897,7 +5393,25 @@ var ActivityFilters = ({
         {
           selectedTypes: selectedQuestionTypes,
           onToggleType: toggleQuestionType,
-          allowedQuestionTypes
+          allowedQuestionTypes: availableQuestionTypes
+        }
+      ),
+      loadingQuestionTypes && /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(
+        Text_default,
+        {
+          size: "sm",
+          className: "text-text-600",
+          "data-testid": "question-types-loading",
+          children: "Carregando tipos de quest\xE3o..."
+        }
+      ),
+      questionTypesError && /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(
+        Text_default,
+        {
+          size: "sm",
+          className: "text-error-500",
+          "data-testid": "question-types-error",
+          children: questionTypesError
         }
       ),
       /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)("div", { children: [
@@ -4950,7 +5464,7 @@ var ActivityFiltersPopover = ({
   triggerLabel = "Filtro de quest\xF5es",
   ...activityFiltersProps
 }) => {
-  const [open, setOpen] = (0, import_react13.useState)(false);
+  const [open, setOpen] = (0, import_react14.useState)(false);
   return /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)(DropdownMenu_default, { open, onOpenChange: setOpen, children: [
     /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(DropdownMenuTrigger, { children: /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(Button_default, { variant: "outline", children: triggerLabel }) }),
     /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(