@orjok/commons 1.0.2 → 1.2.0

package/dist/hooks.cjs

@@ -1,4 +1,17 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/hooks/useOrjokClient.ts
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+
+
+
+var _chunkODXD2WJNcjs = require('./chunk-ODXD2WJN.cjs');
+
+// src/hooks/useOrjokClient.ts
 var _react = require('react');
 var OrjokContext = _react.createContext.call(void 0, null);
 var OrjokProvider = OrjokContext.Provider;
@@ -10,7 +23,631 @@ function useOrjokClient() {
   return client;
 }
 
+// src/hooks/useMediaUrl.ts
+var _reactquery = require('@tanstack/react-query');
+function useMediaUrl(key) {
+  const client = useOrjokClient();
+  const isResolvable = Boolean(key && _chunkODXD2WJNcjs.isStorageKey.call(void 0, key));
+  const query = _reactquery.useQuery.call(void 0, {
+    queryKey: ["media-url", key],
+    queryFn: async () => {
+      if (!key) return null;
+      return _chunkODXD2WJNcjs.resolveMediaUrl.call(void 0, key, client.storage);
+    },
+    enabled: isResolvable,
+    staleTime: 50 * 60 * 1e3
+    // 50 mins
+  });
+  if (!key) {
+    return { url: null, isLoading: false };
+  }
+  if (!_chunkODXD2WJNcjs.isStorageKey.call(void 0, key)) {
+    return { url: key, isLoading: false };
+  }
+  return {
+    url: _nullishCoalesce(query.data, () => ( null)),
+    isLoading: query.isLoading
+  };
+}
+
+// src/hooks/useCurriculum.ts
+
+function useCurriculum({ level, subjectId, chapterId } = {}) {
+  const client = useOrjokClient();
+  const subjectsQuery = _reactquery.useQuery.call(void 0, {
+    queryKey: ["curriculum-subjects", level],
+    queryFn: () => level ? client.curriculum.getSubjects(level) : Promise.resolve([]),
+    enabled: Boolean(level)
+  });
+  const chaptersQuery = _reactquery.useQuery.call(void 0, {
+    queryKey: ["curriculum-chapters", subjectId],
+    queryFn: () => subjectId ? client.curriculum.getChapters(subjectId) : Promise.resolve([]),
+    enabled: Boolean(subjectId)
+  });
+  const topicsQuery = _reactquery.useQuery.call(void 0, {
+    queryKey: ["curriculum-topics", chapterId],
+    queryFn: () => chapterId ? client.curriculum.getTopics(chapterId) : Promise.resolve([]),
+    enabled: Boolean(chapterId)
+  });
+  return {
+    subjects: _nullishCoalesce(subjectsQuery.data, () => ( [])),
+    chapters: _nullishCoalesce(chaptersQuery.data, () => ( [])),
+    topics: _nullishCoalesce(topicsQuery.data, () => ( [])),
+    isLoadingSubjects: subjectsQuery.isLoading,
+    isLoadingChapters: chaptersQuery.isLoading,
+    isLoadingTopics: topicsQuery.isLoading
+  };
+}
+
+// src/hooks/useQuestions.ts
+
+function useQuestions({
+  subjectId,
+  chapterId,
+  topicId,
+  language,
+  difficulty,
+  limit = 20,
+  nextToken
+} = {}) {
+  const client = useOrjokClient();
+  const lang = language === "All" ? void 0 : language;
+  const diff = difficulty === "All" ? void 0 : difficulty;
+  const query = _reactquery.useQuery.call(void 0, {
+    queryKey: ["questions", { subjectId, chapterId, topicId, language, difficulty, limit, nextToken }],
+    queryFn: async () => {
+      if (topicId) {
+        return client.questions.listByTopic({ id: topicId, language: lang, difficulty: diff, limit, nextToken: nextToken || void 0 });
+      }
+      if (chapterId) {
+        return client.questions.listByChapter({ id: chapterId, language: lang, difficulty: diff, limit, nextToken: nextToken || void 0 });
+      }
+      if (subjectId) {
+        return client.questions.listBySubject({ id: subjectId, language: lang, difficulty: diff, limit, nextToken: nextToken || void 0 });
+      }
+      return { items: [], nextToken: null };
+    },
+    enabled: Boolean(subjectId || chapterId || topicId)
+  });
+  return {
+    questions: _nullishCoalesce(_optionalChain([query, 'access', _ => _.data, 'optionalAccess', _2 => _2.items]), () => ( [])),
+    nextToken: _nullishCoalesce(_optionalChain([query, 'access', _3 => _3.data, 'optionalAccess', _4 => _4.nextToken]), () => ( null)),
+    isLoading: query.isLoading,
+    refetch: query.refetch
+  };
+}
+
+// src/hooks/usePacks.ts
+
+function usePacks({
+  subjectId,
+  chapterId,
+  topicId,
+  language,
+  difficulty,
+  limit = 20,
+  nextToken
+} = {}) {
+  const client = useOrjokClient();
+  const lang = language === "All" ? void 0 : language;
+  const diff = difficulty === "All" ? void 0 : difficulty;
+  const query = _reactquery.useQuery.call(void 0, {
+    queryKey: ["packs", { subjectId, chapterId, topicId, language, difficulty, limit, nextToken }],
+    queryFn: async () => {
+      if (topicId) {
+        return client.packs.listByTopic({ id: topicId, language: lang, difficulty: diff, limit, nextToken: nextToken || void 0 });
+      }
+      if (chapterId) {
+        return client.packs.listByChapter({ id: chapterId, language: lang, difficulty: diff, limit, nextToken: nextToken || void 0 });
+      }
+      if (subjectId) {
+        return client.packs.listBySubject({ id: subjectId, language: lang, difficulty: diff, limit, nextToken: nextToken || void 0 });
+      }
+      return { items: [], nextToken: null };
+    },
+    enabled: Boolean(subjectId || chapterId || topicId)
+  });
+  return {
+    packs: _nullishCoalesce(_optionalChain([query, 'access', _5 => _5.data, 'optionalAccess', _6 => _6.items]), () => ( [])),
+    nextToken: _nullishCoalesce(_optionalChain([query, 'access', _7 => _7.data, 'optionalAccess', _8 => _8.nextToken]), () => ( null)),
+    isLoading: query.isLoading,
+    refetch: query.refetch
+  };
+}
+function usePackDetail(packId) {
+  const client = useOrjokClient();
+  const query = _reactquery.useQuery.call(void 0, {
+    queryKey: ["pack-detail", packId],
+    queryFn: async () => {
+      if (!packId) return null;
+      return client.packs.getFull(packId);
+    },
+    enabled: Boolean(packId)
+  });
+  return {
+    pack: _nullishCoalesce(query.data, () => ( null)),
+    questions: _nullishCoalesce(_optionalChain([query, 'access', _9 => _9.data, 'optionalAccess', _10 => _10.questions, 'optionalAccess', _11 => _11.items]), () => ( [])),
+    isLoading: query.isLoading,
+    refetch: query.refetch
+  };
+}
+
+// src/hooks/useContest.ts
+
+function useContest(contestId, checkParticipation = false) {
+  const client = useOrjokClient();
+  const contestQuery = _reactquery.useQuery.call(void 0, {
+    queryKey: ["contest", contestId],
+    queryFn: async () => {
+      if (!contestId) return null;
+      return client.contests.get(contestId);
+    },
+    enabled: Boolean(contestId)
+  });
+  const partQuery = _reactquery.useQuery.call(void 0, {
+    queryKey: ["contest-participation", contestId],
+    queryFn: async () => {
+      if (!contestId || !checkParticipation) return null;
+      return client.contests.checkParticipation(contestId);
+    },
+    enabled: Boolean(contestId && checkParticipation)
+  });
+  return {
+    contest: _nullishCoalesce(contestQuery.data, () => ( null)),
+    participation: _nullishCoalesce(partQuery.data, () => ( null)),
+    isLoading: contestQuery.isLoading || checkParticipation && partQuery.isLoading,
+    refetch: async () => {
+      await Promise.all([contestQuery.refetch(), partQuery.refetch()]);
+    }
+  };
+}
+function useContestsList({ level, nextToken } = {}) {
+  const client = useOrjokClient();
+  const query = _reactquery.useQuery.call(void 0, {
+    queryKey: ["contests-list", level, nextToken],
+    queryFn: () => client.contests.list(nextToken, level)
+  });
+  return {
+    contests: _nullishCoalesce(_optionalChain([query, 'access', _12 => _12.data, 'optionalAccess', _13 => _13.items]), () => ( [])),
+    nextToken: _nullishCoalesce(_optionalChain([query, 'access', _14 => _14.data, 'optionalAccess', _15 => _15.nextToken]), () => ( null)),
+    isLoading: query.isLoading,
+    refetch: query.refetch
+  };
+}
+
+// src/hooks/useCourse.ts
+
+function useCourse(courseId) {
+  const client = useOrjokClient();
+  const query = _reactquery.useQuery.call(void 0, {
+    queryKey: ["course", courseId],
+    queryFn: async () => {
+      if (!courseId) return null;
+      return client.courses.get(courseId);
+    },
+    enabled: Boolean(courseId)
+  });
+  return {
+    course: _nullishCoalesce(query.data, () => ( null)),
+    isLoading: query.isLoading,
+    refetch: query.refetch
+  };
+}
+function useCourseItems(courseId) {
+  const client = useOrjokClient();
+  const query = _reactquery.useQuery.call(void 0, {
+    queryKey: ["course-items", courseId],
+    queryFn: async () => {
+      if (!courseId) return [];
+      return client.courses.getItems(courseId);
+    },
+    enabled: Boolean(courseId)
+  });
+  return {
+    items: _nullishCoalesce(query.data, () => ( [])),
+    isLoading: query.isLoading,
+    refetch: query.refetch
+  };
+}
+function useCourseLiveExams(courseId) {
+  const client = useOrjokClient();
+  const query = _reactquery.useQuery.call(void 0, {
+    queryKey: ["course-live-exams", courseId],
+    queryFn: async () => {
+      if (!courseId) return { items: [], nextToken: null };
+      return client.courses.getLiveExams(courseId);
+    },
+    enabled: Boolean(courseId)
+  });
+  return {
+    exams: _nullishCoalesce(_optionalChain([query, 'access', _16 => _16.data, 'optionalAccess', _17 => _17.items]), () => ( [])),
+    isLoading: query.isLoading,
+    refetch: query.refetch
+  };
+}
+
+// src/hooks/useProgress.ts
+
+function useProgress(userId) {
+  const client = useOrjokClient();
+  const subjectsQuery = _reactquery.useQuery.call(void 0, {
+    queryKey: ["user-subject-progress", userId],
+    queryFn: () => userId ? client.progress.getSubjectProgress(userId) : Promise.resolve([]),
+    enabled: Boolean(userId)
+  });
+  const chaptersQuery = _reactquery.useQuery.call(void 0, {
+    queryKey: ["user-chapter-progress", userId],
+    queryFn: () => userId ? client.progress.getChapterProgress(userId) : Promise.resolve([]),
+    enabled: Boolean(userId)
+  });
+  const topicsQuery = _reactquery.useQuery.call(void 0, {
+    queryKey: ["user-topic-progress", userId],
+    queryFn: () => userId ? client.progress.getTopicProgress(userId) : Promise.resolve([]),
+    enabled: Boolean(userId)
+  });
+  const subjectsProgress = _nullishCoalesce(subjectsQuery.data, () => ( []));
+  const chaptersProgress = _nullishCoalesce(chaptersQuery.data, () => ( []));
+  const topicsProgress = _nullishCoalesce(topicsQuery.data, () => ( []));
+  const metrics = _chunkODXD2WJNcjs.aggregateSubjectMetrics.call(void 0, subjectsProgress);
+  return {
+    subjectsProgress,
+    chaptersProgress,
+    topicsProgress,
+    metrics,
+    isLoading: subjectsQuery.isLoading || chaptersQuery.isLoading || topicsQuery.isLoading,
+    refetch: async () => {
+      await Promise.all([
+        subjectsQuery.refetch(),
+        chaptersQuery.refetch(),
+        topicsQuery.refetch()
+      ]);
+    }
+  };
+}
+
+// src/hooks/usePractice.ts
+
+function usePractice({
+  subjectId,
+  chapterIds = [],
+  topicIds = [],
+  language = "Bangla",
+  difficulty = "All",
+  userId,
+  isCreator
+} = {}) {
+  const client = useOrjokClient();
+  const [mode, setMode] = _react.useState.call(void 0, "setup");
+  const [questions, setQuestions] = _react.useState.call(void 0, []);
+  const [currentIdx, setCurrentIdx] = _react.useState.call(void 0, 0);
+  const [selectedOption, setSelectedOption] = _react.useState.call(void 0, null);
+  const [isAnswered, setIsAnswered] = _react.useState.call(void 0, false);
+  const [isCorrect, setIsCorrect] = _react.useState.call(void 0, null);
+  const [score, setScore] = _react.useState.call(void 0, 0);
+  const [totalPracticed, setTotalPracticed] = _react.useState.call(void 0, 0);
+  const [isLoading, setIsLoading] = _react.useState.call(void 0, false);
+  const [isValidating, setIsValidating] = _react.useState.call(void 0, false);
+  const fetchQuestionsPool = _react.useCallback.call(void 0, async () => {
+    const bounds = [];
+    if (topicIds.length > 0) {
+      topicIds.forEach((tId) => bounds.push({ id: tId, type: "topic" }));
+    } else if (chapterIds.length > 0) {
+      chapterIds.forEach((cId) => bounds.push({ id: cId, type: "chapter" }));
+    } else if (subjectId) {
+      bounds.push({ id: subjectId, type: "subject" });
+    }
+    if (bounds.length === 0) return [];
+    const queries = bounds.map(async (b) => {
+      try {
+        if (b.type === "topic") {
+          return await client.questions.listByTopic({ id: b.id, limit: 50 });
+        } else if (b.type === "chapter") {
+          return await client.questions.listByChapter({ id: b.id, limit: 50 });
+        } else {
+          return await client.questions.listBySubject({ id: b.id, limit: 50 });
+        }
+      } catch (e) {
+        console.error("Error fetching bounds query in practice:", b, e);
+        return { items: [] };
+      }
+    });
+    const results = await Promise.all(queries);
+    const uniqueMap = /* @__PURE__ */ new Map();
+    results.forEach((r) => {
+      (r.items || []).forEach((q) => {
+        if (q && q.id && !uniqueMap.has(q.id)) {
+          uniqueMap.set(q.id, q);
+        }
+      });
+    });
+    let list = Array.from(uniqueMap.values()).filter((q) => {
+      if (!_chunkODXD2WJNcjs.isLanguageMatch.call(void 0, q.language, language)) return false;
+      if (!_chunkODXD2WJNcjs.isDifficultyMatch.call(void 0, q.difficulty, difficulty)) return false;
+      return true;
+    });
+    if (list.length < 5 && subjectId && bounds.some((b) => b.type !== "subject")) {
+      try {
+        const subRes = await client.questions.listBySubject({ id: subjectId, limit: 50 });
+        (subRes.items || []).forEach((q) => {
+          if (q && q.id && !uniqueMap.has(q.id)) {
+            if (_chunkODXD2WJNcjs.isLanguageMatch.call(void 0, q.language, language) && _chunkODXD2WJNcjs.isDifficultyMatch.call(void 0, q.difficulty, difficulty)) {
+              list.push(q);
+              uniqueMap.set(q.id, q);
+            }
+          }
+        });
+      } catch (e) {
+        console.error("Error fetching subject fallback in practice:", e);
+      }
+    }
+    return list.filter(_chunkODXD2WJNcjs.isValidMCQ);
+  }, [client, subjectId, chapterIds, topicIds, language, difficulty]);
+  const startPractice = _react.useCallback.call(void 0, async () => {
+    setIsLoading(true);
+    setMode("practice");
+    setCurrentIdx(0);
+    setScore(0);
+    setTotalPracticed(0);
+    setSelectedOption(null);
+    setIsAnswered(false);
+    setIsCorrect(null);
+    try {
+      const fetched = await fetchQuestionsPool();
+      setQuestions(_chunkODXD2WJNcjs.shuffle.call(void 0, fetched));
+    } catch (e) {
+      console.error("Error starting practice:", e);
+      setQuestions([]);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [fetchQuestionsPool]);
+  const selectOption = _react.useCallback.call(void 0, 
+    async (optionId) => {
+      if (isAnswered || isValidating || questions.length === 0) return;
+      setSelectedOption(optionId);
+      setIsValidating(true);
+      const currentQ = questions[currentIdx];
+      if (!currentQ) {
+        setIsValidating(false);
+        return;
+      }
+      try {
+        const fullQ = await client.questions.get(currentQ.id);
+        const ansVal = _optionalChain([fullQ, 'optionalAccess', _18 => _18.answer]);
+        const rawOpts = currentQ.options;
+        const optsList = Array.isArray(rawOpts) ? rawOpts : rawOpts && typeof rawOpts === "object" && Array.isArray(rawOpts.items) ? rawOpts.items : [];
+        const chosenOpt = optsList.find((o) => _optionalChain([o, 'optionalAccess', _19 => _19.id]) === optionId);
+        const correct = Boolean(
+          ansVal && (ansVal === optionId || chosenOpt && ansVal === chosenOpt.content)
+        );
+        setIsCorrect(correct);
+        setIsAnswered(true);
+        setTotalPracticed((prev) => prev + 1);
+        if (correct) setScore((prev) => prev + 1);
+        if (userId && isCreator) {
+          void client.progress.track({
+            questionId: currentQ.id,
+            isCorrect: correct,
+            subjectId: currentQ.subjectId || subjectId,
+            chapterId: currentQ.chapterId || (chapterIds.length === 1 ? chapterIds[0] : void 0),
+            topicId: currentQ.topicId || (topicIds.length === 1 ? topicIds[0] : void 0)
+          }).catch((e) => console.error("Tracking practice progress error:", e));
+        }
+      } catch (err) {
+        console.error("Error validating option in practice:", err);
+      } finally {
+        setIsValidating(false);
+      }
+    },
+    [client, isAnswered, isValidating, questions, currentIdx, userId, isCreator, subjectId, chapterIds, topicIds]
+  );
+  const nextQuestion = _react.useCallback.call(void 0, () => {
+    if (questions.length === 0) return;
+    if (currentIdx + 1 < questions.length) {
+      setCurrentIdx((prev) => prev + 1);
+      setSelectedOption(null);
+      setIsAnswered(false);
+      setIsCorrect(null);
+    } else {
+      setQuestions((prev) => _chunkODXD2WJNcjs.shuffle.call(void 0, prev));
+      setCurrentIdx(0);
+      setSelectedOption(null);
+      setIsAnswered(false);
+      setIsCorrect(null);
+    }
+  }, [questions.length, currentIdx]);
+  const finishPractice = _react.useCallback.call(void 0, () => {
+    setMode("summary");
+  }, []);
+  const resetPractice = _react.useCallback.call(void 0, () => {
+    setMode("setup");
+    setQuestions([]);
+    setCurrentIdx(0);
+    setScore(0);
+    setTotalPracticed(0);
+    setSelectedOption(null);
+    setIsAnswered(false);
+    setIsCorrect(null);
+  }, []);
+  const accuracy = totalPracticed > 0 ? Math.round(score / totalPracticed * 100) : 0;
+  return {
+    mode,
+    questions,
+    currentIdx,
+    currentQuestion: _nullishCoalesce(questions[currentIdx], () => ( null)),
+    selectedOption,
+    isAnswered,
+    isCorrect,
+    score,
+    totalPracticed,
+    accuracy,
+    isLoading,
+    isValidating,
+    startPractice,
+    selectOption,
+    nextQuestion,
+    finishPractice,
+    resetPractice
+  };
+}
+
+// src/hooks/useAvailablePublicExams.ts
+
+
+function useAvailablePublicExams({
+  level,
+  exploreType = "Question",
+  enabled = true,
+  client: directClient
+} = {}) {
+  let contextClient = null;
+  try {
+    contextClient = useOrjokClient();
+  } catch (e2) {
+  }
+  const client = _nullishCoalesce(directClient, () => ( contextClient));
+  const candidateExams = _react.useMemo.call(void 0, () => _chunkODXD2WJNcjs.getPublicExamsByLevel.call(void 0, level), [level]);
+  const query = _reactquery.useQuery.call(void 0, {
+    queryKey: ["availablePublicExams", level, exploreType],
+    queryFn: async () => {
+      if (!client || !level || candidateExams.length === 0) return candidateExams;
+      const results = await Promise.all(
+        candidateExams.map(async (exam) => {
+          try {
+            if (exploreType === "Pack") {
+              const res = await client.packs.listByPublicExam({
+                publicExam: exam.value,
+                limit: 1
+              });
+              return (_nullishCoalesce(_optionalChain([res, 'access', _20 => _20.items, 'optionalAccess', _21 => _21.length]), () => ( 0))) > 0 ? exam : null;
+            } else {
+              const res = await client.questions.listByPublicExam({
+                publicExam: exam.value,
+                limit: 1
+              });
+              return (_nullishCoalesce(_optionalChain([res, 'access', _22 => _22.items, 'optionalAccess', _23 => _23.length]), () => ( 0))) > 0 ? exam : null;
+            }
+          } catch (e3) {
+            return null;
+          }
+        })
+      );
+      return results.filter((e) => e !== null);
+    },
+    enabled: Boolean(level) && enabled,
+    staleTime: 10 * 60 * 1e3,
+    gcTime: 30 * 60 * 1e3
+  });
+  if (!enabled || !level) {
+    return {
+      availableExams: candidateExams,
+      isLoading: false,
+      isSuccess: true,
+      refetch: async () => candidateExams
+    };
+  }
+  return {
+    availableExams: _nullishCoalesce(query.data, () => ( [])),
+    isLoading: query.isLoading,
+    isSuccess: query.isSuccess,
+    refetch: query.refetch
+  };
+}
+
+// src/hooks/useNotifications.ts
+
+function useNotifications(userId, lastReadAnnouncementAt) {
+  const client = useOrjokClient();
+  const queryClient = _reactquery.useQueryClient.call(void 0, );
+  const announcementsQuery = _reactquery.useQuery.call(void 0, {
+    queryKey: ["notifications-announcements"],
+    queryFn: async () => {
+      const result = await client.notifications.listAnnouncements(50);
+      return result.items || [];
+    },
+    enabled: Boolean(userId),
+    refetchInterval: 3e4
+    // Poll every 30s
+  });
+  const userNotificationsQuery = _reactquery.useQuery.call(void 0, {
+    queryKey: ["notifications-user", userId],
+    queryFn: async () => {
+      if (!userId) return [];
+      const result = await client.notifications.listUserNotifications(userId, 50);
+      return result.items || [];
+    },
+    enabled: Boolean(userId),
+    refetchInterval: 3e4
+  });
+  const announcements = _nullishCoalesce(announcementsQuery.data, () => ( []));
+  const userNotifications = _nullishCoalesce(userNotificationsQuery.data, () => ( []));
+  const timeline = _chunkODXD2WJNcjs.mergeNotificationTimeline.call(void 0, {
+    announcements,
+    userNotifications,
+    lastReadAnnouncementAt
+  });
+  const unreadCount = _chunkODXD2WJNcjs.calculateUnreadCount.call(void 0, {
+    announcements,
+    userNotifications,
+    lastReadAnnouncementAt
+  });
+  const markAsReadMutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: (id) => client.notifications.markNotificationAsRead(id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["notifications-user", userId] });
+    }
+  });
+  const deleteAnnouncementMutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: (id) => client.notifications.deleteAnnouncement(id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["notifications-announcements"] });
+    }
+  });
+  const deleteUserNotificationMutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: (id) => client.notifications.deleteUserNotification(id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["notifications-user", userId] });
+    }
+  });
+  return {
+    announcements,
+    userNotifications,
+    timeline,
+    unreadCount,
+    isLoading: announcementsQuery.isLoading || Boolean(userId) && userNotificationsQuery.isLoading,
+    refetch: async () => {
+      await Promise.all([
+        announcementsQuery.refetch(),
+        userId ? userNotificationsQuery.refetch() : Promise.resolve()
+      ]);
+    },
+    markNotificationAsRead: async (id) => {
+      return markAsReadMutation.mutateAsync(id);
+    },
+    deleteAnnouncement: async (id) => {
+      return deleteAnnouncementMutation.mutateAsync(id);
+    },
+    deleteUserNotification: async (id) => {
+      return deleteUserNotificationMutation.mutateAsync(id);
+    }
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
-exports.OrjokProvider = OrjokProvider; exports.useOrjokClient = useOrjokClient;
+exports.OrjokProvider = OrjokProvider; exports.useAvailablePublicExams = useAvailablePublicExams; exports.useContest = useContest; exports.useContestsList = useContestsList; exports.useCourse = useCourse; exports.useCourseItems = useCourseItems; exports.useCourseLiveExams = useCourseLiveExams; exports.useCurriculum = useCurriculum; exports.useMediaUrl = useMediaUrl; exports.useNotifications = useNotifications; exports.useOrjokClient = useOrjokClient; exports.usePackDetail = usePackDetail; exports.usePacks = usePacks; exports.usePractice = usePractice; exports.useProgress = useProgress; exports.useQuestions = useQuestions;
 //# sourceMappingURL=hooks.cjs.map