@speakableio/core 0.1.2 → 0.1.3

package/dist/index.mjs

@@ -47,13 +47,21 @@ var FirebaseAPI = class _FirebaseAPI {
     this.config = config;
   }
   get db() {
-    if (!this.config) throw new Error("FirebaseAPI not initialized");
+    if (!this.config) throw new Error("Firebase API not initialized");
     return this.config.db;
   }
   get helpers() {
-    if (!this.config) throw new Error("FirebaseAPI not initialized");
+    if (!this.config) throw new Error("Firebase API not initialized");
     return this.config.helpers;
   }
+  get functions() {
+    if (!this.config) throw new Error("Firebase API not initialized");
+    return this.config.functions;
+  }
+  httpsCallable(functionName) {
+    if (!this.config) throw new Error("Firebase API httpsCallable not initialized");
+    return this.config.httpsCallable(this.functions, functionName);
+  }
   accessQueryConstraints() {
     const { query, orderBy, limit, startAt, startAfter, endAt, endBefore } = this.helpers;
     return {
@@ -66,13 +74,27 @@ var FirebaseAPI = class _FirebaseAPI {
       endBefore
     };
   }
+  accessHelpers() {
+    const { doc, collection, writeBatch, serverTimestamp, setDoc } = this.helpers;
+    return {
+      doc: (path) => doc(this.db, path),
+      collection: (path) => collection(this.db, path),
+      writeBatch: () => writeBatch(this.db),
+      serverTimestamp,
+      setDoc
+    };
+  }
   async getDoc(path) {
     const { getDoc, doc } = this.helpers;
     const docRef = doc(this.db, path);
     const docSnap = await getDoc(docRef);
+    const data = docSnap.exists() ? {
+      id: docSnap.id,
+      ...docSnap.data()
+    } : null;
     return {
       id: docSnap.id,
-      data: docSnap.exists() ? docSnap.data() : null
+      data
     };
   }
   async getDocs(path, ...queryConstraints) {
@@ -93,12 +115,15 @@ var FirebaseAPI = class _FirebaseAPI {
     const { addDoc, collection } = this.helpers;
     const collectionRef = collection(this.db, path);
     const docRef = await addDoc(collectionRef, data);
-    return docRef.id;
+    return {
+      id: docRef.id,
+      ...data
+    };
   }
-  async setDoc(path, data) {
+  async setDoc(path, data, options = {}) {
     const { setDoc, doc } = this.helpers;
     const docRef = doc(this.db, path);
-    await setDoc(docRef, data);
+    await setDoc(docRef, data, options);
   }
   async updateDoc(path, data) {
     const { updateDoc, doc } = this.helpers;
@@ -120,6 +145,11 @@ var FirebaseAPI = class _FirebaseAPI {
     await Promise.all(operations.map((op) => op()));
     await batch.commit();
   }
+  writeBatch() {
+    const { writeBatch } = this.helpers;
+    const batch = writeBatch(this.db);
+    return batch;
+  }
 };
 var api = FirebaseAPI.getInstance();
 
@@ -136,10 +166,10 @@ var ANALYTICS_SUBCOLLECTION = "analytics";
 var SCORES_SUBCOLLECTION = "scores";
 var refsAssignmentFiresotre = {
   allAssignments: () => ASSIGNMENTS_COLLECTION,
-  assignment: (id) => `${ASSIGNMENTS_COLLECTION}/${id}`,
-  assignmentAllAnalytics: (id) => `${ASSIGNMENTS_COLLECTION}/${id}/${ANALYTICS_SUBCOLLECTION}`,
-  assignmentAnalytics: (id, type) => `${ASSIGNMENTS_COLLECTION}/${id}/${ANALYTICS_SUBCOLLECTION}/${type}`,
-  assignmentScores: (id, userId) => `${ASSIGNMENTS_COLLECTION}/${id}/${SCORES_SUBCOLLECTION}/${userId}`
+  assignment: (params) => `${ASSIGNMENTS_COLLECTION}/${params.id}`,
+  assignmentAllAnalytics: (params) => `${ASSIGNMENTS_COLLECTION}/${params.id}/${ANALYTICS_SUBCOLLECTION}`,
+  assignmentAnalytics: (params) => `${ASSIGNMENTS_COLLECTION}/${params.id}/${ANALYTICS_SUBCOLLECTION}/${params.type}`,
+  assignmentScores: (params) => `${ASSIGNMENTS_COLLECTION}/${params.id}/${SCORES_SUBCOLLECTION}/${params.userId}`
 };
 
 // src/domains/assignment/services/get-assignments-score.service.ts
@@ -150,21 +180,30 @@ var _getAssignmentScores = async ({
   currentUserId
 }) => {
   if (analyticType === "student" /* Student */) {
-    const path = refsAssignmentFiresotre.assignmentScores(assignmentId, currentUserId);
+    const path = refsAssignmentFiresotre.assignmentScores({
+      id: assignmentId,
+      userId: currentUserId
+    });
     const response = await api.getDoc(path);
     return { scores: response.data, id: assignmentId };
   }
   if (analyticType === "student_summary" /* StudentSummary */ && studentId) {
-    const path = refsAssignmentFiresotre.assignmentScores(assignmentId, studentId);
+    const path = refsAssignmentFiresotre.assignmentScores({
+      id: assignmentId,
+      userId: studentId
+    });
     const response = await api.getDoc(path);
     return { scores: response.data, id: assignmentId };
   }
   if (analyticType !== "all" /* All */ && ASSIGNMENT_ANALYTICS_TYPES.includes(analyticType)) {
-    const ref = refsAssignmentFiresotre.assignmentAnalytics(assignmentId, analyticType);
+    const ref = refsAssignmentFiresotre.assignmentAnalytics({
+      id: assignmentId,
+      type: analyticType
+    });
     const docData = await api.getDoc(ref);
     return { scores: docData.data, id: assignmentId };
   } else if (analyticType === "all" /* All */) {
-    const ref = refsAssignmentFiresotre.assignmentAllAnalytics(assignmentId);
+    const ref = refsAssignmentFiresotre.assignmentAllAnalytics({ id: assignmentId });
     const response = await api.getDocs(ref);
     const data = response.data.reduce((acc, curr) => {
       acc[curr.id] = curr;
@@ -230,7 +269,7 @@ var checkAssignmentAvailability = (scheduledTime) => {
 
 // src/domains/assignment/services/get-assignment.service.ts
 async function _getAssignment(params) {
-  const path = refsAssignmentFiresotre.assignment(params.assignmentId);
+  const path = refsAssignmentFiresotre.assignment({ id: params.assignmentId });
   const response = await api.getDoc(path);
   if (!response.data) return null;
   const assignment = response.data;
@@ -263,7 +302,7 @@ var createAssignmentRepo = () => {
   };
 };
 
-// src/domains/assignment/assignment.hooks.ts
+// src/domains/assignment/hooks/assignment.hooks.ts
 import { useQuery } from "@tanstack/react-query";
 var assignmentQueryKeys = {
   all: ["assignments"],
@@ -288,16 +327,609 @@ function useAssignment({
   });
 }
 
+// src/domains/cards/card.hooks.ts
+import { useMutation, useQueries } from "@tanstack/react-query";
+import { useMemo } from "react";
+
+// src/domains/cards/card.constants.ts
+var FeedbackTypesCard = /* @__PURE__ */ ((FeedbackTypesCard2) => {
+  FeedbackTypesCard2["SuggestedResponse"] = "suggested_response";
+  FeedbackTypesCard2["Wida"] = "wida";
+  FeedbackTypesCard2["GrammarInsights"] = "grammar_insights";
+  FeedbackTypesCard2["Actfl"] = "actfl";
+  FeedbackTypesCard2["ProficiencyLevel"] = "proficiency_level";
+  return FeedbackTypesCard2;
+})(FeedbackTypesCard || {});
+var LeniencyCard = /* @__PURE__ */ ((LeniencyCard2) => {
+  LeniencyCard2["CONFIDENCE"] = "confidence";
+  LeniencyCard2["EASY"] = "easy";
+  LeniencyCard2["NORMAL"] = "normal";
+  LeniencyCard2["HARD"] = "hard";
+  return LeniencyCard2;
+})(LeniencyCard || {});
+var LENIENCY_OPTIONS = [
+  {
+    label: "Build Confidence - most lenient",
+    value: "confidence" /* CONFIDENCE */
+  },
+  {
+    label: "Very Lenient",
+    value: "easy" /* EASY */
+  },
+  {
+    label: "Normal",
+    value: "normal" /* NORMAL */
+  },
+  {
+    label: "No leniency - most strict",
+    value: "hard" /* HARD */
+  }
+];
+var STUDENT_LEVELS_OPTIONS = [
+  {
+    label: "Beginner",
+    description: "Beginner Level: Just starting out. Can say a few basic words and phrases.",
+    value: "beginner"
+  },
+  {
+    label: "Elementary",
+    description: "Elementary Level: Can understand simple sentences and have very basic conversations.",
+    value: "elementary"
+  },
+  {
+    label: "Intermediate",
+    description: "Intermediate Level: Can talk about everyday topics and handle common situations.",
+    value: "intermediate"
+  },
+  {
+    label: "Advanced",
+    description: "Advanced Level: Can speak and understand with ease, and explain ideas clearly.",
+    value: "advanced"
+  },
+  {
+    label: "Fluent",
+    description: "Fluent Level: Speaks naturally and easily. Can use the language in work or school settings.",
+    value: "fluent"
+  },
+  {
+    label: "Native-like",
+    description: "Native-like Level: Understands and speaks like a native. Can discuss complex ideas accurately.",
+    value: "nativeLike"
+  }
+];
+var BASE_RESPOND_FIELD_VALUES = {
+  title: "",
+  allowRetries: true,
+  respondTime: 180,
+  maxCharacters: 1e3
+};
+var BASE_REPEAT_FIELD_VALUES = {
+  repeat: 1
+};
+var BASE_MULTIPLE_CHOICE_FIELD_VALUES = {
+  MCQType: "single",
+  answer: ["A"],
+  choices: [
+    { option: "A", value: "Option A" },
+    { option: "B", value: "Option B" },
+    { option: "C", value: "Option C" }
+  ]
+};
+var VerificationCardStatus = /* @__PURE__ */ ((VerificationCardStatus2) => {
+  VerificationCardStatus2["VERIFIED"] = "VERIFIED";
+  VerificationCardStatus2["WARNING"] = "WARNING";
+  VerificationCardStatus2["NOT_RECOMMENDED"] = "NOT_RECOMMENDED";
+  VerificationCardStatus2["NOT_WORKING"] = "NOT_WORKING";
+  VerificationCardStatus2["NOT_CHECKED"] = "NOT_CHECKED";
+  return VerificationCardStatus2;
+})(VerificationCardStatus || {});
+var CARDS_COLLECTION = "flashcards";
+var refsCardsFiresotre = {
+  allCards: CARDS_COLLECTION,
+  card: (id) => `${CARDS_COLLECTION}/${id}`
+};
+
+// src/domains/cards/services/get-card.service.ts
+async function _getCard(params) {
+  const ref = refsCardsFiresotre.card(params.cardId);
+  const response = await api.getDoc(ref);
+  if (!response.data) return null;
+  return response.data;
+}
+var getCard = withErrorHandler(_getCard, "getCard");
+
+// src/domains/cards/services/create-card.service.ts
+import { v4 } from "uuid";
+
+// src/domains/cards/card.model.ts
+var CardActivityType = /* @__PURE__ */ ((CardActivityType2) => {
+  CardActivityType2["READ_REPEAT"] = "READ_REPEAT";
+  CardActivityType2["VIDEO"] = "VIDEO";
+  CardActivityType2["TEXT"] = "TEXT";
+  CardActivityType2["READ_RESPOND"] = "READ_RESPOND";
+  CardActivityType2["FREE_RESPONSE"] = "FREE_RESPONSE";
+  CardActivityType2["REPEAT"] = "REPEAT";
+  CardActivityType2["RESPOND"] = "RESPOND";
+  CardActivityType2["RESPOND_WRITE"] = "RESPOND_WRITE";
+  CardActivityType2["TEXT_TO_SPEECH"] = "TEXT_TO_SPEECH";
+  CardActivityType2["MULTIPLE_CHOICE"] = "MULTIPLE_CHOICE";
+  CardActivityType2["PODCAST"] = "PODCAST";
+  CardActivityType2["MEDIA_PAGE"] = "MEDIA_PAGE";
+  CardActivityType2["WRITE"] = "WRITE";
+  CardActivityType2["SHORT_ANSWER"] = "SHORT_ANSWER";
+  CardActivityType2["SHORT_STORY"] = "SHORT_STORY";
+  CardActivityType2["SPEAK"] = "SPEAK";
+  CardActivityType2["CONVERSATION"] = "CONVERSATION";
+  CardActivityType2["CONVERSATION_WRITE"] = "CONVERSATION_WRITE";
+  CardActivityType2["DIALOGUE"] = "DIALOGUE";
+  CardActivityType2["INSTRUCTION"] = "INSTRUCTION";
+  CardActivityType2["LISTEN"] = "LISTEN";
+  CardActivityType2["READ"] = "READ";
+  CardActivityType2["ANSWER"] = "ANSWER";
+  return CardActivityType2;
+})(CardActivityType || {});
+var RESPOND_CARD_ACTIVITY_TYPES = [
+  "READ_RESPOND" /* READ_RESPOND */,
+  "RESPOND" /* RESPOND */,
+  "RESPOND_WRITE" /* RESPOND_WRITE */,
+  "FREE_RESPONSE" /* FREE_RESPONSE */
+];
+var MULTIPLE_CHOICE_CARD_ACTIVITY_TYPES = ["MULTIPLE_CHOICE" /* MULTIPLE_CHOICE */];
+var REPEAT_CARD_ACTIVITY_TYPES = ["READ_REPEAT" /* READ_REPEAT */, "REPEAT" /* REPEAT */];
+var RESPOND_WRITE_CARD_ACTIVITY_TYPES = [
+  "RESPOND_WRITE" /* RESPOND_WRITE */,
+  "FREE_RESPONSE" /* FREE_RESPONSE */
+];
+var RESPOND_AUDIO_CARD_ACTIVITY_TYPES = [
+  "RESPOND" /* RESPOND */,
+  "READ_RESPOND" /* READ_RESPOND */
+];
+var ALLOWED_CARD_ACTIVITY_TYPES_FOR_SUMMARY = [
+  "REPEAT" /* REPEAT */,
+  "RESPOND" /* RESPOND */,
+  "READ_REPEAT" /* READ_REPEAT */,
+  "READ_RESPOND" /* READ_RESPOND */,
+  "FREE_RESPONSE" /* FREE_RESPONSE */,
+  "RESPOND_WRITE" /* RESPOND_WRITE */,
+  "MULTIPLE_CHOICE" /* MULTIPLE_CHOICE */
+];
+
+// src/utils/text-utils.ts
+import sha1 from "js-sha1";
+var purify = (word) => {
+  return word.normalize("NFD").replace(/\/([^" "]*)/g, "").replace(/\([^()]*\)/g, "").replace(/（[^()]*）/g, "").replace(/[\u0300-\u036f]/g, "").replace(/[-]/g, " ").replace(/[.,/#!¡¿？؟。，.?$%^&*;:{}=\-_`~()’'…\s]/g, "").replace(/\s\s+/g, " ").toLowerCase().trim();
+};
+var cleanString = (words) => {
+  const splitWords = words?.split("+");
+  if (splitWords && splitWords.length === 1) {
+    const newWord = purify(words);
+    return newWord;
+  } else if (splitWords && splitWords.length > 1) {
+    const split = splitWords.map((w) => purify(w));
+    return split;
+  } else {
+    return "";
+  }
+};
+var getWordHash = (word, language) => {
+  const cleanedWord = cleanString(word);
+  const wordHash = sha1(`${language}-${cleanedWord}`);
+  return wordHash;
+};
+
+// src/domains/cards/services/get-card-verification-status.service.ts
+var charactarLanguages = ["zh", "ja", "ko"];
+var getVerificationStatus = async (target_text, language) => {
+  if (target_text?.length < 3 && !charactarLanguages.includes(language)) {
+    return "NOT_RECOMMENDED" /* NOT_RECOMMENDED */;
+  }
+  const hash = getWordHash(target_text, language);
+  const response = await api.getDoc(`checked-pronunciations/${hash}`);
+  try {
+    if (response.data) {
+      return processRecord(response.data);
+    } else {
+      return "NOT_CHECKED" /* NOT_CHECKED */;
+    }
+  } catch (e) {
+    return "NOT_CHECKED" /* NOT_CHECKED */;
+  }
+};
+var processRecord = (data) => {
+  const { pronunciations = 0, fails = 0 } = data;
+  const attempts = pronunciations + fails;
+  const successRate = attempts > 0 ? pronunciations / attempts * 100 : 0;
+  let newStatus = null;
+  if (attempts < 6) {
+    return "NOT_CHECKED" /* NOT_CHECKED */;
+  }
+  if (successRate > 25) {
+    newStatus = "VERIFIED" /* VERIFIED */;
+  } else if (successRate > 10) {
+    newStatus = "WARNING" /* WARNING */;
+  } else if (fails > 20 && successRate < 10 && pronunciations > 1) {
+    newStatus = "NOT_RECOMMENDED" /* NOT_RECOMMENDED */;
+  } else if (pronunciations === 0 && fails > 20) {
+    newStatus = "NOT_WORKING" /* NOT_WORKING */;
+  } else {
+    newStatus = "NOT_CHECKED" /* NOT_CHECKED */;
+  }
+  return newStatus;
+};
+
+// src/domains/cards/services/create-card.service.ts
+async function _createCard({ data }) {
+  const response = await api.addDoc(refsCardsFiresotre.allCards, data);
+  return response;
+}
+var createCard = withErrorHandler(_createCard, "createCard");
+async function _createCards({ cards }) {
+  const { writeBatch, doc } = api.accessHelpers();
+  const batch = writeBatch();
+  const cardsWithId = [];
+  for (const card of cards) {
+    const cardId = v4();
+    const ref = doc(refsCardsFiresotre.card(cardId));
+    const newCardObject = {
+      ...card,
+      id: cardId
+    };
+    if (card.type === "READ_REPEAT" /* READ_REPEAT */ && card.target_text && card.language) {
+      const verificationStatus = await getVerificationStatus(card.target_text, card.language);
+      newCardObject.verificationStatus = verificationStatus || null;
+    }
+    cardsWithId.push(newCardObject);
+    batch.set(ref, newCardObject);
+  }
+  await batch.commit();
+  return cardsWithId;
+}
+var createCards = withErrorHandler(_createCards, "createCards");
+
+// src/domains/cards/card.hooks.ts
+var cardsQueryKeys = {
+  all: ["cards"],
+  one: (params) => [...cardsQueryKeys.all, params.cardId]
+};
+function useCards({
+  cardIds,
+  enabled = true,
+  asObject
+}) {
+  const queries = useQueries({
+    queries: cardIds.map((cardId) => ({
+      enabled: enabled && cardIds.length > 0,
+      queryKey: cardsQueryKeys.one({
+        cardId
+      }),
+      queryFn: () => getCard({ cardId })
+    }))
+  });
+  const cards = queries.map((query) => query.data).filter(Boolean);
+  const cardsObject = useMemo(() => {
+    if (!asObject) return null;
+    return cards.reduce((acc, card) => {
+      acc[card.id] = card;
+      return acc;
+    }, {});
+  }, [asObject, cards]);
+  return {
+    cards,
+    cardsObject,
+    cardsQueries: queries
+  };
+}
+function useCreateCard() {
+  const { queryClient } = useSpeakableApi();
+  const mutationCreateCard = useMutation({
+    mutationFn: createCard,
+    onSuccess: (cardCreated) => {
+      queryClient.invalidateQueries({ queryKey: cardsQueryKeys.one({ cardId: cardCreated.id }) });
+    }
+  });
+  return {
+    mutationCreateCard
+  };
+}
+function useCreateCards() {
+  const mutationCreateCards = useMutation({
+    mutationFn: createCards
+  });
+  return {
+    mutationCreateCards
+  };
+}
+function getCardFromCache({
+  cardId,
+  queryClient
+}) {
+  return queryClient.getQueryData(cardsQueryKeys.one({ cardId }));
+}
+function updateCardInCache({
+  cardId,
+  card,
+  queryClient
+}) {
+  queryClient.setQueryData(cardsQueryKeys.one({ cardId }), card);
+}
+
+// src/domains/cards/card.repo.ts
+var createCardRepo = () => {
+  return {
+    createCard,
+    createCards,
+    getCard
+  };
+};
+
+// src/domains/sets/set.hooks.ts
+import { useQuery as useQuery2 } from "@tanstack/react-query";
+
+// src/domains/sets/set.constants.ts
+var SETS_COLLECTION = "sets";
+var refsSetsFirestore = {
+  allSets: SETS_COLLECTION,
+  set: (id) => `${SETS_COLLECTION}/${id}`
+};
+
+// src/domains/sets/services/get-set.service.ts
+async function _getSet({ setId }) {
+  const response = await api.getDoc(refsSetsFirestore.set(setId));
+  return response.data;
+}
+var getSet = withErrorHandler(_getSet, "getSet");
+
+// src/domains/sets/set.hooks.ts
+var setsQueryKeys = {
+  all: ["sets"],
+  one: (params) => [...setsQueryKeys.all, params.setId]
+};
+var useSet = ({ setId, enabled }) => {
+  return useQuery2({
+    queryKey: setsQueryKeys.one({ setId }),
+    queryFn: () => getSet({ setId }),
+    enabled: setId !== void 0 && setId !== "" && enabled
+  });
+};
+function getSetFromCache({
+  setId,
+  queryClient
+}) {
+  if (!setId) return null;
+  return queryClient.getQueryData(setsQueryKeys.one({ setId }));
+}
+function updateSetInCache({
+  set,
+  queryClient
+}) {
+  const { id, ...setData } = set;
+  queryClient.setQueryData(setsQueryKeys.one({ setId: id }), setData);
+}
+
+// src/domains/sets/set.repo.ts
+var createSetRepo = () => {
+  return {
+    getSet
+  };
+};
+
+// src/domains/notification/notification.constants.ts
+var SPEAKABLE_NOTIFICATIONS = {
+  NEW_ASSIGNMENT: "new_assignment",
+  ASSESSMENT_SUBMITTED: "assessment_submitted",
+  ASSESSMENT_SCORED: "assessment_scored",
+  NEW_COMMENT: "NEW_COMMENT"
+};
+var SpeakableNotificationTypes = {
+  NEW_ASSIGNMENT: "NEW_ASSIGNMENT",
+  FEEDBACK_FROM_TEACHER: "FEEDBACK_FROM_TEACHER",
+  MESSAGE_FROM_STUDENT: "MESSAGE_FROM_STUDENT",
+  PHRASE_MARKED_CORRECT: "PHRASE_MARKED_CORRECT",
+  STUDENT_PROGRESS: "STUDENT_PROGRESS",
+  PLAYLIST_FOLLOWERS: "PLAYLIST_FOLLOWERS",
+  PLAYLIST_PLAYS: "PLAYLIST_PLAYS",
+  // New notifications
+  ASSESSMENT_SUBMITTED: "ASSESSMENT_SUBMITTED",
+  // Notification FOR TEACHER when student submits assessment
+  ASSESSMENT_SCORED: "ASSESSMENT_SCORED",
+  // Notification FOR STUDENT when teacher scores assessment
+  // Comment
+  NEW_COMMENT: "NEW_COMMENT"
+};
+
+// src/domains/notification/services/create-notification.service.ts
+import dayjs2 from "dayjs";
+
+// src/constants/web.constants.ts
+var WEB_BASE_URL = "https://app.speakable.io";
+
+// src/lib/firebase/firebase-functions.ts
+var SpeakableFirebaseFunctions = {
+  updateAssignmentGradebookStatus: api.httpsCallable("updateAssignmentGradebookStatus"),
+  onSetOpened: api.httpsCallable("onSetOpened"),
+  updateAlgoliaIndex: api.httpsCallable("updateAlgoliaIndex"),
+  submitAssignmentToGoogleClassroomV2: api.httpsCallable("submitAssignmentToGoogleClassroomV2"),
+  submitLTIAssignmentScore: api.httpsCallable("submitLTIAssignmentScore"),
+  submitAssignmentV2: api.httpsCallable("submitLTIAssignmentScoreV2"),
+  submitAssessment: api.httpsCallable("submitAssessment"),
+  sendAssessmentScoredEmail: api.httpsCallable("sendAssessmentScoredEmail"),
+  createNotification: api.httpsCallable("createNotificationV2")
+};
+
+// src/domains/notification/services/send-notification.service.ts
+var _sendNotification = async (sendTo, notification) => {
+  const results = await SpeakableFirebaseFunctions.createNotification({
+    sendTo,
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    notification
+  });
+  return results;
+};
+var sendNotification = withErrorHandler(_sendNotification, "sendNotification");
+
+// src/domains/notification/services/create-notification.service.ts
+var createNotification = async ({
+  data,
+  type,
+  userId,
+  profile
+}) => {
+  let result;
+  switch (type) {
+    case SPEAKABLE_NOTIFICATIONS.NEW_ASSIGNMENT:
+      result = await handleAssignNotifPromise({ data, profile });
+      break;
+    case SPEAKABLE_NOTIFICATIONS.ASSESSMENT_SUBMITTED:
+      result = await createAssessmentSubmissionNotification({
+        data,
+        profile,
+        userId
+      });
+      break;
+    case SPEAKABLE_NOTIFICATIONS.ASSESSMENT_SCORED:
+      result = await createAssessmentScoredNotification({
+        data,
+        profile
+      });
+      break;
+    default:
+      result = null;
+      break;
+  }
+  return result;
+};
+var handleAssignNotifPromise = async ({
+  data: assignments,
+  profile
+}) => {
+  if (!assignments.length) return;
+  try {
+    const notifsPromises = assignments.map(async (assignment) => {
+      const {
+        section,
+        section: { members },
+        ...rest
+      } = assignment;
+      if (!section || !members) throw new Error("Invalid assignment data");
+      const data = { section, sendTo: members, assignment: { ...rest } };
+      return createNewAssignmentNotification({ data, profile });
+    });
+    await Promise.all(notifsPromises);
+    return {
+      success: true,
+      message: "Assignment notifications sent successfully"
+    };
+  } catch (error) {
+    console.error("Error in handleAssignNotifPromise:", error);
+    throw error;
+  }
+};
+var createNewAssignmentNotification = async ({
+  data,
+  profile
+}) => {
+  const { assignment, sendTo } = data;
+  const teacherName = profile.displayName || "Your teacher";
+  const dueDate = assignment.dueDateTimestamp ? dayjs2(assignment.dueDateTimestamp.toDate()).format("MMM Do") : null;
+  const results = await sendNotification(sendTo, {
+    courseId: assignment.courseId,
+    type: SPEAKABLE_NOTIFICATIONS.NEW_ASSIGNMENT,
+    senderName: teacherName,
+    link: `${WEB_BASE_URL}/assignment/${assignment.id}`,
+    messagePreview: `A new assignment "${assignment.name}" is now available. ${dueDate ? `Due ${dueDate}` : ""}`,
+    title: "New Assignment Available!",
+    imageUrl: profile.image?.url
+  });
+  return results;
+};
+var createAssessmentSubmissionNotification = async ({
+  data: assignment,
+  profile,
+  userId
+}) => {
+  const studentName = profile.displayName || "Your student";
+  const results = await sendNotification(assignment.owners, {
+    courseId: assignment.courseId,
+    type: SPEAKABLE_NOTIFICATIONS.ASSESSMENT_SUBMITTED,
+    link: `${WEB_BASE_URL}/a/${assignment.id}?studentId=${userId}`,
+    title: `Assessment Submitted!`,
+    senderName: studentName,
+    messagePreview: `${studentName} has submitted the assessment "${assignment.name}"`,
+    imageUrl: profile.image?.url
+  });
+  return results;
+};
+var createAssessmentScoredNotification = async ({
+  data,
+  profile
+}) => {
+  const { assignment, sendTo } = data;
+  const teacherName = profile.displayName || "Your teacher";
+  const title = `${assignment.isAssessment ? "Assessment" : "Assignment"} Reviewed!`;
+  const messagePreview = `Your ${assignment.isAssessment ? "assessment" : "assignment"} has been reviewed by your teacher. Click to view the feedback.`;
+  const results = await sendNotification(sendTo, {
+    courseId: assignment.courseId,
+    type: SPEAKABLE_NOTIFICATIONS.ASSESSMENT_SCORED,
+    link: `${WEB_BASE_URL}/assignment/${assignment.id}`,
+    title,
+    messagePreview,
+    imageUrl: profile.image?.url,
+    senderName: teacherName
+  });
+  await SpeakableFirebaseFunctions.sendAssessmentScoredEmail({
+    assessmentTitle: assignment.name,
+    link: `${WEB_BASE_URL}/assignment/${assignment.id}`,
+    senderImage: profile.image?.url || "",
+    studentId: sendTo[0],
+    teacherName: profile.displayName
+  });
+  return results;
+};
+
+// src/domains/notification/hooks/notification.hooks.ts
+var notificationQueryKeys = {
+  all: ["notifications"],
+  byId: (id) => [...notificationQueryKeys.all, id]
+};
+var useCreateNotification = () => {
+  const { user, queryClient } = useSpeakableApi();
+  const handleCreateNotifications = async (type, data) => {
+    const result = await createNotification({
+      type,
+      userId: user?.auth.uid ?? "",
+      profile: user?.profile ?? {},
+      data
+    });
+    queryClient.invalidateQueries({
+      queryKey: notificationQueryKeys.byId(user?.auth.uid ?? "")
+    });
+    return result;
+  };
+  return {
+    createNotification: handleCreateNotifications
+  };
+};
+
 // src/lib/create-firebase-client.ts
-async function createFsClient(db, platform) {
+import { httpsCallable as webHttpsCallable } from "firebase/functions";
+import { httpsCallable as nativeHttpsCallable } from "@react-native-firebase/functions";
+async function createFsClient({
+  db,
+  platform,
+  functions
+}) {
   const dbAsFirestore = db;
   const helpers = platform === "web" ? await import("firebase/firestore") : await import("@react-native-firebase/firestore");
+  const httpsCallable = platform === "web" ? webHttpsCallable : nativeHttpsCallable;
   api.initialize({
     db: dbAsFirestore,
-    helpers
+    helpers,
+    functions,
+    httpsCallable
   });
   return {
-    assignmentRepo: createAssignmentRepo()
+    assignmentRepo: createAssignmentRepo(),
+    cardRepo: createCardRepo()
   };
 }
 
@@ -308,21 +940,33 @@ function SpeakableProvider({
   db,
   platform,
   children,
-  queryClient
+  queryClient,
+  user,
+  permissions,
+  firebaseFunctions,
+  localStorage
 }) {
   const [speakableApi, setSpeakableApi] = useState(null);
   useEffect(() => {
-    createFsClient(db, platform).then((repos) => {
+    createFsClient({
+      db,
+      platform,
+      functions: firebaseFunctions
+    }).then((repos) => {
       setSpeakableApi(repos);
     });
-  }, [db, platform]);
+  }, [db, firebaseFunctions, platform]);
   if (!speakableApi) return null;
   return /* @__PURE__ */ jsx(
     FsCtx.Provider,
     {
       value: {
         speakableApi,
-        queryClient
+        queryClient,
+        user,
+        permissions,
+        firebaseFunctions,
+        localStorage
       },
       children
     }
@@ -334,11 +978,43 @@ function useSpeakableApi() {
   return ctx;
 }
 export {
+  ALLOWED_CARD_ACTIVITY_TYPES_FOR_SUMMARY,
+  BASE_MULTIPLE_CHOICE_FIELD_VALUES,
+  BASE_REPEAT_FIELD_VALUES,
+  BASE_RESPOND_FIELD_VALUES,
+  CardActivityType,
+  FeedbackTypesCard,
   FsCtx,
+  LENIENCY_OPTIONS,
+  LeniencyCard,
+  MULTIPLE_CHOICE_CARD_ACTIVITY_TYPES,
+  REPEAT_CARD_ACTIVITY_TYPES,
+  RESPOND_AUDIO_CARD_ACTIVITY_TYPES,
+  RESPOND_CARD_ACTIVITY_TYPES,
+  RESPOND_WRITE_CARD_ACTIVITY_TYPES,
+  SPEAKABLE_NOTIFICATIONS,
+  STUDENT_LEVELS_OPTIONS,
+  SpeakableNotificationTypes,
   SpeakableProvider,
+  VerificationCardStatus,
   assignmentQueryKeys,
+  cardsQueryKeys,
   createAssignmentRepo,
+  createCardRepo,
   createFsClient,
+  createSetRepo,
+  getCardFromCache,
+  getSetFromCache,
+  refsCardsFiresotre,
+  refsSetsFirestore,
+  setsQueryKeys,
+  updateCardInCache,
+  updateSetInCache,
   useAssignment,
+  useCards,
+  useCreateCard,
+  useCreateCards,
+  useCreateNotification,
+  useSet,
   useSpeakableApi
 };