@speakableio/core 0.1.11 → 0.1.12

package/dist/index.js

@@ -55,7 +55,7 @@ var FirebaseAPI = class _FirebaseAPI {
     return this.config.helpers;
   }
   httpsCallable(functionName) {
-    return _optionalChain([this, 'access', _ => _.config, 'optionalAccess', _2 => _2.httpsCallable, 'call', _3 => _3(functionName)]);
+    return _optionalChain([this, 'access', _2 => _2.config, 'optionalAccess', _3 => _3.httpsCallable, 'call', _4 => _4(functionName)]);
   }
   accessQueryConstraints() {
     const { query, orderBy, limit, startAt, startAfter, endAt, endBefore } = this.helpers;
@@ -495,7 +495,7 @@ 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 = _optionalChain([words, 'optionalAccess', _4 => _4.split, 'call', _5 => _5("+")]);
+  const splitWords = _optionalChain([words, 'optionalAccess', _5 => _5.split, 'call', _6 => _6("+")]);
   if (splitWords && splitWords.length === 1) {
     const newWord = purify(words);
     return newWord;
@@ -515,7 +515,7 @@ var getWordHash = (word, language) => {
 // src/domains/cards/services/get-card-verification-status.service.ts
 var charactarLanguages = ["zh", "ja", "ko"];
 var getVerificationStatus = async (target_text, language) => {
-  if (_optionalChain([target_text, 'optionalAccess', _6 => _6.length]) < 3 && !charactarLanguages.includes(language)) {
+  if (_optionalChain([target_text, 'optionalAccess', _7 => _7.length]) < 3 && !charactarLanguages.includes(language)) {
     return "NOT_RECOMMENDED" /* NOT_RECOMMENDED */;
   }
   const hash = getWordHash(target_text, language);
@@ -753,11 +753,11 @@ var SpeakableFirebaseFunctions = {
 
 // src/domains/notification/services/send-notification.service.ts
 var _sendNotification = async (sendTo, notification) => {
-  const results = await SpeakableFirebaseFunctions.createNotification({
+  const results = await _optionalChain([SpeakableFirebaseFunctions, 'access', _8 => _8.createNotification, 'optionalCall', _9 => _9({
     sendTo,
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     notification
-  });
+  })]);
   return results;
 };
 var sendNotification = withErrorHandler(_sendNotification, "sendNotification");
@@ -833,7 +833,7 @@ var createNewAssignmentNotification = async ({
     link: `${WEB_BASE_URL}/assignment/${assignment.id}`,
     messagePreview: `A new assignment "${assignment.name}" is now available. ${dueDate ? `Due ${dueDate}` : ""}`,
     title: "New Assignment Available!",
-    imageUrl: _optionalChain([profile, 'access', _7 => _7.image, 'optionalAccess', _8 => _8.url])
+    imageUrl: _optionalChain([profile, 'access', _10 => _10.image, 'optionalAccess', _11 => _11.url])
   });
   return results;
 };
@@ -850,7 +850,7 @@ var createAssessmentSubmissionNotification = async ({
     title: `Assessment Submitted!`,
     senderName: studentName,
     messagePreview: `${studentName} has submitted the assessment "${assignment.name}"`,
-    imageUrl: _optionalChain([profile, 'access', _9 => _9.image, 'optionalAccess', _10 => _10.url])
+    imageUrl: _optionalChain([profile, 'access', _12 => _12.image, 'optionalAccess', _13 => _13.url])
   });
   return results;
 };
@@ -868,16 +868,16 @@ var createAssessmentScoredNotification = async ({
     link: `${WEB_BASE_URL}/assignment/${assignment.id}`,
     title,
     messagePreview,
-    imageUrl: _optionalChain([profile, 'access', _11 => _11.image, 'optionalAccess', _12 => _12.url]),
+    imageUrl: _optionalChain([profile, 'access', _14 => _14.image, 'optionalAccess', _15 => _15.url]),
     senderName: teacherName
   });
-  await SpeakableFirebaseFunctions.sendAssessmentScoredEmail({
+  await _optionalChain([SpeakableFirebaseFunctions, 'access', _16 => _16.sendAssessmentScoredEmail, 'optionalCall', _17 => _17({
     assessmentTitle: assignment.name,
     link: `${WEB_BASE_URL}/assignment/${assignment.id}`,
-    senderImage: _optionalChain([profile, 'access', _13 => _13.image, 'optionalAccess', _14 => _14.url]) || "",
+    senderImage: _optionalChain([profile, 'access', _18 => _18.image, 'optionalAccess', _19 => _19.url]) || "",
     studentId: sendTo[0],
     teacherName: profile.displayName
-  });
+  })]);
   return results;
 };
 
@@ -892,11 +892,11 @@ var useCreateNotification = () => {
     const result = await createNotification({
       type,
       userId: user.auth.uid,
-      profile: _nullishCoalesce(_optionalChain([user, 'optionalAccess', _15 => _15.profile]), () => ( {})),
+      profile: _nullishCoalesce(_optionalChain([user, 'optionalAccess', _20 => _20.profile]), () => ( {})),
       data
     });
     queryClient.invalidateQueries({
-      queryKey: notificationQueryKeys.byId(_nullishCoalesce(_optionalChain([user, 'optionalAccess', _16 => _16.auth, 'access', _17 => _17.uid]), () => ( "")))
+      queryKey: notificationQueryKeys.byId(_nullishCoalesce(_optionalChain([user, 'optionalAccess', _21 => _21.auth, 'access', _22 => _22.uid]), () => ( "")))
     });
     return result;
   };
@@ -966,6 +966,1068 @@ function useSpeakableApi() {
   return ctx;
 }
 
+// src/domains/assignment/hooks/score-hooks.ts
+
+
+// src/utils/debounce.utils.ts
+function debounce(func, waitFor) {
+  let timeoutId;
+  return (...args) => new Promise((resolve, reject) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(async () => {
+      try {
+        const result = await func(...args);
+        resolve(result);
+      } catch (error) {
+        reject(error);
+      }
+    }, waitFor);
+  });
+}
+
+// src/lib/tanstack/handle-optimistic-update-query.ts
+var handleOptimisticUpdate = async ({
+  queryClient,
+  queryKey,
+  newData
+}) => {
+  await queryClient.cancelQueries({
+    queryKey
+  });
+  const previousData = queryClient.getQueryData(queryKey);
+  if (previousData === void 0) {
+    queryClient.setQueryData(queryKey, newData);
+  } else {
+    queryClient.setQueryData(queryKey, { ...previousData, ...newData });
+  }
+  return { previousData };
+};
+
+// src/constants/speakable-plans.ts
+var FEEDBACK_PLANS = {
+  FEEDBACK_TRANSCRIPT: "FEEDBACK_TRANSCRIPT",
+  // Transcript from the audio
+  FEEDBACK_SUMMARY: "FEEDBACK_SUMMARY",
+  // Chatty summary (Free plan)
+  FEEDBACK_GRAMMAR_INSIGHTS: "FEEDBACK_GRAMMAR_INSIGHTS",
+  // Grammar insights
+  FEEDBACK_SUGGESTED_RESPONSE: "FEEDBACK_SUGGESTED_RESPONSE",
+  // Suggested Response
+  FEEDBACK_RUBRIC: "FEEDBACK_RUBRIC",
+  // Suggested Response
+  FEEDBACK_GRADING_STANDARDS: "FEEDBACK_GRADING_STANDARDS",
+  // ACTFL / WIDA Estimate
+  FEEDBACK_TARGET_LANGUAGE: "FEEDBACK_TARGET_LANGUAGE",
+  // Ability to set the feedback language to the target language of the student
+  FEEDBACK_DISABLE_ALLOW_RETRIES: "FEEDBACK_DISABLE_ALLOW_RETRIES"
+  // Turn of allow retries
+};
+var AUTO_GRADING_PLANS = {
+  AUTO_GRADING_PASS_FAIL: "AUTO_GRADING_PASS_FAIL",
+  // Pass / fail grading
+  AUTO_GRADING_RUBRICS: "AUTO_GRADING_RUBRICS",
+  // Autograded rubrics
+  AUTO_GRADING_STANDARDS_BASED: "AUTO_GRADING_STANDARDS_BASED"
+  // Standards based grading
+};
+var AI_ASSISTANT_PLANS = {
+  AI_ASSISTANT_DOCUMENT_UPLOADS: "AI_ASSISTANT_DOCUMENT_UPLOADS",
+  // Allow document uploading
+  AI_ASSISTANT_UNLIMITED_USE: "AI_ASSISTANT_UNLIMITED_USE"
+  // Allow unlimited use of AI assistant. Otherwise, limits are used.
+};
+var ASSIGNMENT_SETTINGS_PLANS = {
+  ASSESSMENTS: "ASSESSMENTS",
+  // Ability to create assessment assignment types
+  GOOGLE_CLASSROOM_GRADE_PASSBACK: "GOOGLE_CLASSROOM_GRADE_PASSBACK"
+  // Assignment scores can sync with classroom
+};
+var ANALYTICS_PLANS = {
+  ANALYTICS_GRADEBOOK: "ANALYTICS_GRADEBOOK",
+  // Access to the gradebook page
+  ANALYTICS_CLASSROOM_ANALYTICS: "ANALYTICS_CLASSROOM_ANALYTICS",
+  // Access to the classroom analytics page
+  ANALYTICS_STUDENT_PROGRESS_REPORTS: "ANALYTICS_STUDENT_PROGRESS_REPORTS",
+  // Access to the panel that shows an individual student's progress and assignments
+  ANALYTICS_ASSIGNMENT_RESULTS: "ANALYTICS_ASSIGNMENT_RESULTS",
+  // Access to the assigment RESULTS page
+  ANALYTICS_ORGANIZATION: "ANALYTICS_ORGANIZATION"
+  // Access to the organization analytics panel (for permitted admins)
+};
+var SPACES_PLANS = {
+  SPACES_CREATE_SPACE: "SPACES_CREATE_SPACE",
+  // Ability to create spaces
+  SPACES_CHECK_POINTS: "SPACES_CHECK_POINTS"
+  // Feature not available yet. Ability to create checkpoints for spaces for data aggregation
+};
+var DISCOVER_PLANS = {
+  DISCOVER_ORGANIZATION_LIBRARY: "DISCOVER_ORGANIZATION_LIBRARY"
+  // Access to the organizations shared library
+};
+var MEDIA_AREA_PLANS = {
+  MEDIA_AREA_DOCUMENT_UPLOAD: "MEDIA_AREA_DOCUMENT_UPLOAD",
+  MEDIA_AREA_AUDIO_FILES: "MEDIA_AREA_AUDIO_FILES"
+};
+var FREE_PLAN = [];
+var TEACHER_PRO_PLAN = [
+  FEEDBACK_PLANS.FEEDBACK_TRANSCRIPT,
+  FEEDBACK_PLANS.FEEDBACK_SUMMARY,
+  FEEDBACK_PLANS.FEEDBACK_TARGET_LANGUAGE,
+  AUTO_GRADING_PLANS.AUTO_GRADING_PASS_FAIL,
+  ANALYTICS_PLANS.ANALYTICS_GRADEBOOK,
+  SPACES_PLANS.SPACES_CREATE_SPACE
+  // AUTO_GRADING_PLANS.AUTO_GRADING_STANDARDS_BASED,
+];
+var SCHOOL_STARTER = [
+  FEEDBACK_PLANS.FEEDBACK_TRANSCRIPT,
+  FEEDBACK_PLANS.FEEDBACK_SUMMARY,
+  FEEDBACK_PLANS.FEEDBACK_GRAMMAR_INSIGHTS,
+  FEEDBACK_PLANS.FEEDBACK_SUGGESTED_RESPONSE,
+  FEEDBACK_PLANS.FEEDBACK_RUBRIC,
+  FEEDBACK_PLANS.FEEDBACK_GRADING_STANDARDS,
+  FEEDBACK_PLANS.FEEDBACK_DISABLE_ALLOW_RETRIES,
+  FEEDBACK_PLANS.FEEDBACK_TARGET_LANGUAGE,
+  AUTO_GRADING_PLANS.AUTO_GRADING_PASS_FAIL,
+  AUTO_GRADING_PLANS.AUTO_GRADING_RUBRICS,
+  AUTO_GRADING_PLANS.AUTO_GRADING_STANDARDS_BASED,
+  AI_ASSISTANT_PLANS.AI_ASSISTANT_DOCUMENT_UPLOADS,
+  AI_ASSISTANT_PLANS.AI_ASSISTANT_UNLIMITED_USE,
+  // ASSIGNMENT_SETTINGS_PLANS.ASSESSMENTS,
+  ASSIGNMENT_SETTINGS_PLANS.GOOGLE_CLASSROOM_GRADE_PASSBACK,
+  ANALYTICS_PLANS.ANALYTICS_GRADEBOOK,
+  ANALYTICS_PLANS.ANALYTICS_STUDENT_PROGRESS_REPORTS,
+  ANALYTICS_PLANS.ANALYTICS_CLASSROOM_ANALYTICS,
+  // ANALYTICS_PLANS.ANALYTICS_ORGANIZATION,
+  SPACES_PLANS.SPACES_CREATE_SPACE,
+  SPACES_PLANS.SPACES_CHECK_POINTS,
+  // DISCOVER_PLANS.DISCOVER_ORGANIZATION_LIBRARY,
+  MEDIA_AREA_PLANS.MEDIA_AREA_DOCUMENT_UPLOAD,
+  MEDIA_AREA_PLANS.MEDIA_AREA_AUDIO_FILES
+];
+var ORGANIZATION_PLAN = [
+  FEEDBACK_PLANS.FEEDBACK_TRANSCRIPT,
+  FEEDBACK_PLANS.FEEDBACK_SUMMARY,
+  FEEDBACK_PLANS.FEEDBACK_GRAMMAR_INSIGHTS,
+  FEEDBACK_PLANS.FEEDBACK_SUGGESTED_RESPONSE,
+  FEEDBACK_PLANS.FEEDBACK_RUBRIC,
+  FEEDBACK_PLANS.FEEDBACK_GRADING_STANDARDS,
+  FEEDBACK_PLANS.FEEDBACK_DISABLE_ALLOW_RETRIES,
+  FEEDBACK_PLANS.FEEDBACK_TARGET_LANGUAGE,
+  AUTO_GRADING_PLANS.AUTO_GRADING_PASS_FAIL,
+  AUTO_GRADING_PLANS.AUTO_GRADING_RUBRICS,
+  AUTO_GRADING_PLANS.AUTO_GRADING_STANDARDS_BASED,
+  AI_ASSISTANT_PLANS.AI_ASSISTANT_DOCUMENT_UPLOADS,
+  AI_ASSISTANT_PLANS.AI_ASSISTANT_UNLIMITED_USE,
+  ASSIGNMENT_SETTINGS_PLANS.ASSESSMENTS,
+  ASSIGNMENT_SETTINGS_PLANS.GOOGLE_CLASSROOM_GRADE_PASSBACK,
+  ANALYTICS_PLANS.ANALYTICS_GRADEBOOK,
+  ANALYTICS_PLANS.ANALYTICS_STUDENT_PROGRESS_REPORTS,
+  ANALYTICS_PLANS.ANALYTICS_CLASSROOM_ANALYTICS,
+  ANALYTICS_PLANS.ANALYTICS_ORGANIZATION,
+  SPACES_PLANS.SPACES_CREATE_SPACE,
+  SPACES_PLANS.SPACES_CHECK_POINTS,
+  DISCOVER_PLANS.DISCOVER_ORGANIZATION_LIBRARY,
+  MEDIA_AREA_PLANS.MEDIA_AREA_DOCUMENT_UPLOAD,
+  MEDIA_AREA_PLANS.MEDIA_AREA_AUDIO_FILES
+];
+var SpeakablePlanTypes = {
+  basic: "basic",
+  teacher_pro: "teacher_pro",
+  school_starter: "school_starter",
+  organization: "organization",
+  // OLD PLANS
+  starter: "starter",
+  growth: "growth",
+  professional: "professional"
+};
+var SpeakablePermissionsMap = {
+  [SpeakablePlanTypes.basic]: FREE_PLAN,
+  [SpeakablePlanTypes.starter]: TEACHER_PRO_PLAN,
+  [SpeakablePlanTypes.teacher_pro]: TEACHER_PRO_PLAN,
+  [SpeakablePlanTypes.growth]: ORGANIZATION_PLAN,
+  [SpeakablePlanTypes.professional]: ORGANIZATION_PLAN,
+  [SpeakablePlanTypes.organization]: ORGANIZATION_PLAN,
+  [SpeakablePlanTypes.school_starter]: SCHOOL_STARTER
+};
+var SpeakablePlanHierarchy = [
+  SpeakablePlanTypes.basic,
+  SpeakablePlanTypes.starter,
+  SpeakablePlanTypes.teacher_pro,
+  SpeakablePlanTypes.growth,
+  SpeakablePlanTypes.professional,
+  SpeakablePlanTypes.school_starter,
+  SpeakablePlanTypes.organization
+];
+
+// src/hooks/usePermissions.ts
+var usePermissions = () => {
+  const { permissions } = useSpeakableApi();
+  const has = (permission) => _optionalChain([permissions, 'access', _23 => _23.permissions, 'optionalAccess', _24 => _24.includes, 'call', _25 => _25(permission)]);
+  return {
+    plan: permissions.plan,
+    permissionsLoaded: permissions.loaded,
+    isStripePlan: permissions.isStripePlan,
+    refreshDate: permissions.refreshDate,
+    isInstitutionPlan: permissions.isInstitutionPlan,
+    subscriptionId: permissions.subscriptionId,
+    contact: permissions.contact,
+    hasGradebook: has(ANALYTICS_PLANS.ANALYTICS_GRADEBOOK),
+    hasGoogleClassroomGradePassback: has(ASSIGNMENT_SETTINGS_PLANS.GOOGLE_CLASSROOM_GRADE_PASSBACK),
+    hasAssessments: has(ASSIGNMENT_SETTINGS_PLANS.ASSESSMENTS),
+    hasSectionAnalytics: has(ANALYTICS_PLANS.ANALYTICS_CLASSROOM_ANALYTICS),
+    hasStudentReports: has(ANALYTICS_PLANS.ANALYTICS_STUDENT_PROGRESS_REPORTS),
+    permissions: permissions || [],
+    hasStudentPortfolios: permissions.hasStudentPortfolios,
+    isFreeOrgTrial: permissions.type === "free_org_trial",
+    freeOrgTrialExpired: permissions.freeOrgTrialExpired
+  };
+};
+var usePermissions_default = usePermissions;
+
+// src/hooks/useGoogleClassroom.ts
+var useGoogleClassroom = () => {
+  const submitAssignmentToGoogleClassroom = async ({
+    assignment,
+    scores,
+    googleUserId = null
+    // optional to override the user's googleUserId
+  }) => {
+    try {
+      const { googleClassroomUserId = null } = scores;
+      const googleId = googleUserId || googleClassroomUserId;
+      if (!googleId)
+        return {
+          error: true,
+          message: "No Google Classroom ID found"
+        };
+      const { courseWorkId, maxPoints, owners, courseId } = assignment;
+      const draftGrade = _optionalChain([scores, 'optionalAccess', _26 => _26.score]) ? _optionalChain([scores, 'optionalAccess', _27 => _27.score]) / 100 * maxPoints : 0;
+      const result = await _optionalChain([SpeakableFirebaseFunctions, 'access', _28 => _28.submitAssignmentToGoogleClassroomV2, 'optionalCall', _29 => _29({
+        teacherId: owners[0],
+        courseId,
+        courseWorkId,
+        userId: googleId,
+        draftGrade
+      })]);
+      return result;
+    } catch (error) {
+      return { error: true, message: error.message };
+    }
+  };
+  return {
+    submitAssignmentToGoogleClassroom
+  };
+};
+
+// src/domains/assignment/utils/create-default-score.ts
+var defaultScore = (props) => {
+  const { serverTimestamp } = api.accessHelpers();
+  const score = {
+    progress: 0,
+    score: 0,
+    startDate: serverTimestamp(),
+    status: "IN_PROGRESS",
+    submitted: false,
+    cards: {},
+    lastPlayed: serverTimestamp(),
+    owners: props.owners,
+    userId: props.userId
+  };
+  if (props.googleClassroomUserId) {
+    score.googleClassroomUserId = props.googleClassroomUserId;
+  }
+  if (props.courseId) {
+    score.courseId = props.courseId;
+  }
+  return score;
+};
+
+// src/domains/assignment/score-practice.constants.ts
+var SCORES_PRACTICE_COLLECTION = "users";
+var SCORES_PRACTICE_SUBCOLLECTION = "practice";
+var refsScoresPractice = {
+  practiceScores: (params) => `${SCORES_PRACTICE_COLLECTION}/${params.userId}/${SCORES_PRACTICE_SUBCOLLECTION}/${params.setId}`,
+  practiceScoreHistoryRefDoc: (params) => `${SCORES_PRACTICE_COLLECTION}/${params.userId}/${SCORES_PRACTICE_SUBCOLLECTION}/${params.setId}/attempts/${params.date}`
+};
+
+// src/domains/assignment/services/create-score.service.ts
+async function _createScore(params) {
+  if (params.isAssignment) {
+    const ref = refsAssignmentFiresotre.assignmentScores({
+      id: params.activityId,
+      userId: params.userId
+    });
+    await _optionalChain([SpeakableFirebaseFunctions, 'access', _30 => _30.updateAssignmentGradebookStatus, 'optionalCall', _31 => _31({
+      assignmentId: params.activityId,
+      userId: params.userId,
+      status: "IN_PROGRESS",
+      score: null
+    })]);
+    await api.setDoc(ref, params.scoreData, { merge: true });
+    return {
+      id: params.userId
+    };
+  } else {
+    const ref = refsScoresPractice.practiceScores({
+      userId: params.userId,
+      setId: params.activityId
+    });
+    await api.setDoc(ref, params.scoreData);
+    return {
+      id: params.userId
+    };
+  }
+}
+var createScore = withErrorHandler(_createScore, "createScore");
+
+// src/domains/assignment/services/get-score.service.ts
+async function getAssignmentScore({
+  userId,
+  assignment,
+  googleClassroomUserId
+}) {
+  const path = refsAssignmentFiresotre.assignmentScores({
+    id: assignment.id,
+    userId
+  });
+  const response = await api.getDoc(path);
+  if (response.data == null) {
+    const newScore = {
+      ...defaultScore({
+        owners: [userId],
+        userId,
+        courseId: assignment.courseId,
+        googleClassroomUserId
+      }),
+      assignmentId: assignment.id
+    };
+    const result = await createScore({
+      activityId: assignment.id,
+      userId,
+      isAssignment: true,
+      scoreData: newScore
+    });
+    return {
+      ...newScore,
+      id: result.id
+    };
+  }
+  return response.data;
+}
+async function getPracticeScore({ userId, setId }) {
+  const path = refsScoresPractice.practiceScores({ userId, setId });
+  const response = await api.getDoc(path);
+  if (response.data == null) {
+    const newScore = {
+      ...defaultScore({
+        owners: [userId],
+        userId
+      }),
+      setId
+    };
+    const result = await createScore({
+      activityId: setId,
+      userId,
+      isAssignment: false,
+      scoreData: newScore
+    });
+    return {
+      ...newScore,
+      id: result.id
+    };
+  }
+  return response.data;
+}
+async function _getScore(params) {
+  if (params.isAssignment) {
+    return await getAssignmentScore({
+      userId: params.userId,
+      assignment: {
+        id: params.activityId,
+        courseId: params.courseId
+      },
+      googleClassroomUserId: params.googleClassroomUserId
+    });
+  } else {
+    return await getPracticeScore({
+      userId: params.userId,
+      setId: params.activityId
+    });
+  }
+}
+var getScore = withErrorHandler(_getScore, "getScore");
+
+// src/domains/assignment/utils/calculateScoreAndProgress.ts
+var calculateScoreAndProgress = (scores, cardsList, weights) => {
+  const totalSetPoints = cardsList.reduce((acc, cardId) => {
+    acc += _optionalChain([weights, 'optionalAccess', _32 => _32[cardId]]) || 1;
+    return acc;
+  }, 0);
+  const totalPointsAwarded = Object.keys(_optionalChain([scores, 'optionalAccess', _33 => _33.cards]) || {}).reduce((acc, cardId) => {
+    const cardScores = _optionalChain([scores, 'optionalAccess', _34 => _34.cards, 'optionalAccess', _35 => _35[cardId]]);
+    if (_optionalChain([cardScores, 'optionalAccess', _36 => _36.completed]) || _optionalChain([cardScores, 'optionalAccess', _37 => _37.score]) || _optionalChain([cardScores, 'optionalAccess', _38 => _38.score]) === 0) {
+      const score2 = _optionalChain([cardScores, 'optionalAccess', _39 => _39.score]) || _optionalChain([cardScores, 'optionalAccess', _40 => _40.score]) === 0 ? Number(_nullishCoalesce(_optionalChain([cardScores, 'optionalAccess', _41 => _41.score]), () => ( 0))) : null;
+      const weight = _optionalChain([weights, 'optionalAccess', _42 => _42[cardId]]) || 1;
+      const fraction = (_nullishCoalesce(score2, () => ( 0))) / 100;
+      if (score2 || score2 === 0) {
+        acc += weight * fraction;
+      } else {
+        acc += weight;
+      }
+    }
+    return acc;
+  }, 0);
+  const totalCompletedCards = Object.keys(_optionalChain([scores, 'optionalAccess', _43 => _43.cards]) || {}).reduce((acc, cardId) => {
+    const cardScores = _optionalChain([scores, 'optionalAccess', _44 => _44.cards, 'optionalAccess', _45 => _45[cardId]]);
+    if (_optionalChain([cardScores, 'optionalAccess', _46 => _46.completed]) || _optionalChain([cardScores, 'optionalAccess', _47 => _47.score]) || _optionalChain([cardScores, 'optionalAccess', _48 => _48.score]) === 0) {
+      acc += 1;
+    }
+    return acc;
+  }, 0);
+  const percent = totalPointsAwarded / totalSetPoints;
+  const score = Math.round(percent * 100);
+  const progress = Math.round(totalCompletedCards / (cardsList.length || 1) * 100);
+  return { score, progress };
+};
+var calculateScoreAndProgress_default = calculateScoreAndProgress;
+
+// src/domains/assignment/services/update-score.service.ts
+async function _updateScore(params) {
+  const path = params.isAssignment ? refsAssignmentFiresotre.assignmentScores({
+    id: params.activityId,
+    userId: params.userId
+  }) : refsScoresPractice.practiceScores({
+    setId: params.activityId,
+    userId: params.userId
+  });
+  await api.updateDoc(path, {
+    ...params.data
+  });
+}
+var updateScore = withErrorHandler(_updateScore, "updateScore");
+async function _updateCardScore(params) {
+  const path = params.isAssignment ? refsAssignmentFiresotre.assignmentScores({
+    id: params.activityId,
+    userId: params.userId
+  }) : refsScoresPractice.practiceScores({
+    setId: params.activityId,
+    userId: params.userId
+  });
+  const updates = Object.keys(params.updates.cardScore).reduce(
+    (acc, key) => {
+      acc[`cards.${params.cardId}.${key}`] = params.updates.cardScore[key];
+      return acc;
+    },
+    {}
+  );
+  if (params.updates.progress) {
+    updates.progress = params.updates.progress;
+  }
+  if (params.updates.score) {
+    updates.score = params.updates.score;
+  }
+  await api.updateDoc(path, {
+    ...updates
+  });
+}
+var updateCardScore = withErrorHandler(_updateCardScore, "updateCardScore");
+
+// src/domains/assignment/services/clear-score.service.ts
+
+async function clearScore(params) {
+  const update = {
+    [`cards.${params.cardId}`]: {
+      attempts: _nullishCoalesce(params.cardScores.attempts, () => ( 1)),
+      correct: _nullishCoalesce(params.cardScores.correct, () => ( 0)),
+      // save old score history
+      history: [
+        {
+          ...params.cardScores,
+          attempts: _nullishCoalesce(params.cardScores.attempts, () => ( 1)),
+          correct: _nullishCoalesce(params.cardScores.correct, () => ( 0)),
+          retryTime: _dayjs2.default.call(void 0, ).format("YYYY-MM-DD HH:mm:ss"),
+          history: null
+        },
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        ..._nullishCoalesce(params.cardScores.history, () => ( []))
+      ]
+    }
+  };
+  const path = params.isAssignment ? refsAssignmentFiresotre.assignmentScores({
+    id: params.activityId,
+    userId: params.userId
+  }) : refsScoresPractice.practiceScores({
+    setId: params.activityId,
+    userId: params.userId
+  });
+  await api.updateDoc(path, update);
+  return {
+    update,
+    activityId: params.activityId
+  };
+}
+
+// src/domains/assignment/services/submit-assignment-score.service.ts
+
+async function submitAssignmentScore({
+  cardIds,
+  assignment,
+  setWeights,
+  userId,
+  status,
+  studentName
+}) {
+  const { serverTimestamp } = api.accessHelpers();
+  const path = refsAssignmentFiresotre.assignmentScores({ id: assignment.id, userId });
+  const fieldsUpdated = {
+    submitted: true,
+    progress: 100,
+    submissionDate: serverTimestamp(),
+    status
+  };
+  if (assignment.isAssessment) {
+    const result = await handleAssessment(
+      assignment,
+      userId,
+      cardIds,
+      setWeights,
+      fieldsUpdated,
+      studentName
+    );
+    return result;
+  } else if (assignment.courseId) {
+    await handleCourseAssignment(assignment, userId);
+  }
+  await api.updateDoc(path, { ...fieldsUpdated });
+  return { success: true, fieldsUpdated };
+}
+async function handleAssessment(assignment, userId, cardIds, setWeights, fieldsUpdated, studentName) {
+  const path = refsAssignmentFiresotre.assignmentScores({ id: assignment.id, userId });
+  const response = await api.getDoc(path);
+  if (!response.data) {
+    throw new Error("Score not found");
+  }
+  const { score: scoreCalculated } = calculateScoreAndProgress_default(response.data, cardIds, setWeights);
+  await api.updateDoc(path, { score: scoreCalculated, status: "PENDING_REVIEW" });
+  await _optionalChain([SpeakableFirebaseFunctions, 'access', _49 => _49.submitAssessment, 'optionalCall', _50 => _50({
+    assignmentId: assignment.id,
+    assignmentTitle: assignment.name,
+    userId,
+    teacherId: assignment.owners[0],
+    studentName
+  })]);
+  fieldsUpdated.status = "PENDING_REVIEW";
+  return { success: true, fieldsUpdated };
+}
+async function handleCourseAssignment(assignment, userId) {
+  const { data } = await _optionalChain([SpeakableFirebaseFunctions, 'optionalAccess', _51 => _51.submitAssignmentV2, 'optionalCall', _52 => _52({
+    assignmentId: assignment.id,
+    userId
+  })]);
+}
+async function submitPracticeScore({
+  setId,
+  userId,
+  scores
+}) {
+  const { serverTimestamp } = api.accessHelpers();
+  const date = _dayjs2.default.call(void 0, ).format("YYYY-MM-DD-HH-mm");
+  const ref = refsScoresPractice.practiceScoreHistoryRefDoc({ setId, userId, date });
+  const fieldsUpdated = {
+    ...scores,
+    submitted: true,
+    progress: 100,
+    submissionDate: serverTimestamp(),
+    status: "SUBMITTED"
+  };
+  await api.setDoc(ref, { ...fieldsUpdated });
+  const refScores = refsScoresPractice.practiceScores({ userId, setId });
+  await api.deleteDoc(refScores);
+  return { success: true, fieldsUpdated };
+}
+
+// src/domains/assignment/hooks/score-hooks.ts
+var scoreQueryKeys = {
+  all: ["scores"],
+  byId: (id) => [...scoreQueryKeys.all, id],
+  list: () => [...scoreQueryKeys.all, "list"]
+};
+function useScore({
+  isAssignment,
+  activityId,
+  userId = "",
+  courseId,
+  enabled = true,
+  googleClassroomUserId
+}) {
+  return _reactquery.useQuery.call(void 0, {
+    queryFn: () => getScore({
+      userId,
+      courseId,
+      activityId,
+      googleClassroomUserId,
+      isAssignment
+    }),
+    queryKey: scoreQueryKeys.byId(activityId),
+    enabled
+  });
+}
+var debounceUpdateScore = debounce(updateScore, 1e3);
+function useUpdateScore() {
+  const { queryClient } = useSpeakableApi();
+  const mutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: debounceUpdateScore,
+    onMutate: (variables) => {
+      return handleOptimisticUpdate({
+        queryClient,
+        queryKey: scoreQueryKeys.byId(variables.activityId),
+        newData: variables.data
+      });
+    },
+    onError: (_, variables, context) => {
+      if (_optionalChain([context, 'optionalAccess', _53 => _53.previousData]))
+        queryClient.setQueryData(scoreQueryKeys.byId(variables.activityId), context.previousData);
+    },
+    onSettled: (_, err, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: scoreQueryKeys.byId(variables.activityId)
+      });
+    }
+  });
+  return {
+    mutationUpdateScore: mutation
+  };
+}
+function useUpdateCardScore({
+  isAssignment,
+  activityId,
+  userId
+}) {
+  const { queryClient } = useSpeakableApi();
+  const querySet = useSet({ setId: activityId });
+  const dataCurrentSet = querySet.data;
+  const queryKey = scoreQueryKeys.byId(activityId);
+  const mutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: async ({ cardId, cardScore }) => {
+      const previousScores = queryClient.getQueryData(queryKey);
+      const { progress, score, newScoreUpdated, updatedCardScore } = getScoreUpdated({
+        previousScores: _nullishCoalesce(previousScores, () => ( {})),
+        cardId,
+        set: _nullishCoalesce(dataCurrentSet, () => ( void 0)),
+        cardScore
+      });
+      await updateCardScore({
+        userId,
+        cardId,
+        isAssignment,
+        activityId,
+        updates: {
+          cardScore: updatedCardScore,
+          progress,
+          score
+        }
+      });
+      return { cardId, scoresUpdated: newScoreUpdated };
+    },
+    onMutate: ({ cardId, cardScore }) => {
+      queryClient.setQueryData(queryKey, (previousScore) => {
+        const updates = handleOptimisticScore({
+          score: previousScore,
+          cardId,
+          cardScore,
+          set: _nullishCoalesce(dataCurrentSet, () => ( void 0))
+        });
+        return {
+          ...previousScore,
+          ...updates
+        };
+      });
+    },
+    // eslint-disable-next-line no-unused-vars
+    onError: () => {
+      const previousData = queryClient.getQueryData(queryKey);
+      if (previousData) {
+        queryClient.setQueryData(queryKey, previousData);
+      }
+    }
+  });
+  return {
+    mutationUpdateCardScore: mutation
+  };
+}
+var getScoreUpdated = ({
+  cardId,
+  cardScore,
+  previousScores,
+  set
+}) => {
+  const previousCard = _optionalChain([previousScores, 'access', _54 => _54.cards, 'optionalAccess', _55 => _55[cardId]]);
+  const newCardScore = {
+    ..._nullishCoalesce(previousCard, () => ( {})),
+    ...cardScore
+  };
+  const newScores = {
+    ...previousScores,
+    cards: {
+      ..._nullishCoalesce(previousScores.cards, () => ( {})),
+      [cardId]: newCardScore
+    }
+  };
+  const { score, progress } = calculateScoreAndProgress_default(
+    newScores,
+    _nullishCoalesce(_optionalChain([set, 'optionalAccess', _56 => _56.content]), () => ( [])),
+    _nullishCoalesce(_optionalChain([set, 'optionalAccess', _57 => _57.weights]), () => ( {}))
+  );
+  return {
+    newScoreUpdated: newScores,
+    updatedCardScore: cardScore,
+    score,
+    progress
+  };
+};
+var handleOptimisticScore = ({
+  score,
+  cardId,
+  cardScore,
+  set
+}) => {
+  let cards = { ..._nullishCoalesce(_optionalChain([score, 'optionalAccess', _58 => _58.cards]), () => ( {})) };
+  cards = {
+    ...cards,
+    [cardId]: {
+      ...cards[cardId],
+      ...cardScore
+    }
+  };
+  const { score: scoreValue, progress } = calculateScoreAndProgress_default(
+    // @ts-ignore
+    {
+      ..._nullishCoalesce(score, () => ( {})),
+      cards
+    },
+    _nullishCoalesce(_optionalChain([set, 'optionalAccess', _59 => _59.content]), () => ( [])),
+    _nullishCoalesce(_optionalChain([set, 'optionalAccess', _60 => _60.weights]), () => ( {}))
+  );
+  return { cards, score: scoreValue, progress };
+};
+function useClearScore() {
+  const { queryClient } = useSpeakableApi();
+  const mutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: clearScore,
+    onSettled: (result) => {
+      queryClient.invalidateQueries({
+        queryKey: scoreQueryKeys.byId(_nullishCoalesce(_optionalChain([result, 'optionalAccess', _61 => _61.activityId]), () => ( "")))
+      });
+    }
+  });
+  return {
+    mutationClearScore: mutation
+  };
+}
+function useSubmitAssignmentScore({
+  onAssignmentSubmitted,
+  studentName
+}) {
+  const { queryClient } = useSpeakableApi();
+  const { hasGoogleClassroomGradePassback } = usePermissions_default();
+  const { submitAssignmentToGoogleClassroom } = useGoogleClassroom();
+  const { createNotification: createNotification2 } = useCreateNotification();
+  const mutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: async ({
+      assignment,
+      userId,
+      cardIds,
+      setWeights,
+      scores,
+      status
+    }) => {
+      try {
+        const scoreUpdated = await submitAssignmentScore({
+          assignment,
+          userId,
+          cardIds,
+          setWeights,
+          status,
+          studentName
+        });
+        if (assignment.courseWorkId != null && !assignment.isAssessment && hasGoogleClassroomGradePassback) {
+          await submitAssignmentToGoogleClassroom({
+            assignment,
+            scores
+          });
+        }
+        if (assignment.isAssessment) {
+          createNotification2(SpeakableNotificationTypes.ASSESSMENT_SUBMITTED, assignment);
+        }
+        onAssignmentSubmitted(assignment.id);
+        queryClient.setQueryData(scoreQueryKeys.byId(assignment.id), {
+          ...scores,
+          ...scoreUpdated.fieldsUpdated
+        });
+        return {
+          success: true,
+          message: "Score submitted successfully"
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error
+        };
+      }
+    }
+  });
+  return {
+    submitAssignmentScore: mutation.mutateAsync,
+    isLoading: mutation.isPending
+  };
+}
+function useSubmitPracticeScore() {
+  const { queryClient } = useSpeakableApi();
+  const mutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: async ({
+      setId,
+      userId,
+      scores
+    }) => {
+      try {
+        await submitPracticeScore({
+          setId,
+          userId,
+          scores
+        });
+        queryClient.invalidateQueries({
+          queryKey: scoreQueryKeys.byId(setId)
+        });
+        return {
+          success: true,
+          message: "Score submitted successfully"
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error
+        };
+      }
+    }
+  });
+  return {
+    submitPracticeScore: mutation.mutateAsync,
+    isLoading: mutation.isPending
+  };
+}
+
+// src/hooks/useActivity.ts
+
+
+// src/hooks/useActivityTracker.ts
+
+function useActivityTracker({ userId }) {
+  const trackActivity = async ({
+    activityName,
+    activityType,
+    id = _uuid.v4.call(void 0, ),
+    language = ""
+  }) => {
+    if (userId) {
+      const { doc, serverTimestamp, setDoc } = api.accessHelpers();
+      const activityRef = doc(`users/${userId}/activity${id}`);
+      const timestamp = serverTimestamp();
+      await setDoc(activityRef, {
+        name: activityName,
+        type: activityType,
+        lastSeen: timestamp,
+        id,
+        language
+      });
+    }
+  };
+  return {
+    trackActivity
+  };
+}
+
+// src/hooks/useActivity.ts
+function useActivity({
+  id,
+  isAssignment,
+  onAssignmentSubmitted
+}) {
+  const { queryClient, user } = useSpeakableApi();
+  const userId = user.auth.uid;
+  const assignmentQuery = useAssignment({
+    assignmentId: id,
+    userId,
+    enabled: isAssignment
+  });
+  const activeAssignment = assignmentQuery.data;
+  const activityId = isAssignment ? _nullishCoalesce(_optionalChain([activeAssignment, 'optionalAccess', _62 => _62.setId]), () => ( "")) : id;
+  const querySet = useSet({ setId: _nullishCoalesce(activityId, () => ( "")) });
+  const setData = querySet.data;
+  const { cardsObject, cardsQueries } = useCards({
+    cardIds: _nullishCoalesce(_optionalChain([setData, 'optionalAccess', _63 => _63.content]), () => ( [])),
+    enabled: querySet.isSuccess,
+    asObject: true
+  });
+  const scoreQuery = useScore({
+    isAssignment,
+    activityId: id,
+    userId,
+    courseId: _optionalChain([activeAssignment, 'optionalAccess', _64 => _64.courseId]),
+    googleClassroomUserId: "",
+    // TODO
+    enabled: isAssignment ? assignmentQuery.isSuccess : querySet.isSuccess
+  });
+  const { mutationUpdateScore } = useUpdateScore();
+  const { mutationUpdateCardScore } = useUpdateCardScore({
+    activityId,
+    isAssignment,
+    userId
+  });
+  const { mutationClearScore } = useClearScore();
+  const { submitAssignmentScore: submitAssignmentScore2 } = useSubmitAssignmentScore({
+    onAssignmentSubmitted,
+    studentName: user.profile.displayName
+  });
+  const { submitPracticeScore: submitPracticeScore2 } = useSubmitPracticeScore();
+  const handleUpdateScore = (data) => {
+    mutationUpdateScore.mutate({
+      data,
+      isAssignment,
+      activityId,
+      userId
+    });
+  };
+  const handleUpdateCardScore = (cardId, cardScore) => {
+    mutationUpdateCardScore.mutate({ cardId, cardScore });
+  };
+  const onClearScore = ({
+    cardId,
+    wasCompleted = true
+  }) => {
+    const currentCard = _optionalChain([cardsObject, 'optionalAccess', _65 => _65[cardId]]);
+    if (_optionalChain([currentCard, 'optionalAccess', _66 => _66.type]) === "MULTIPLE_CHOICE" /* MULTIPLE_CHOICE */ || _optionalChain([currentCard, 'optionalAccess', _67 => _67.type]) === "READ_REPEAT" /* READ_REPEAT */) {
+      return;
+    }
+    const queryKeys = scoreQueryKeys.byId(activityId);
+    const activeCardScores = _optionalChain([queryClient, 'access', _68 => _68.getQueryData, 'call', _69 => _69(queryKeys), 'optionalAccess', _70 => _70.cards, 'optionalAccess', _71 => _71[cardId]]);
+    if (activeCardScores === void 0) return;
+    mutationClearScore.mutate({
+      isAssignment,
+      activityId,
+      cardScores: activeCardScores,
+      cardId,
+      userId
+    });
+  };
+  const onSubmitScore = async () => {
+    try {
+      let results;
+      if (isAssignment) {
+        const cardScores = _optionalChain([scoreQuery, 'access', _72 => _72.data, 'optionalAccess', _73 => _73.cards]) || {};
+        const hasPendingReview = Object.values(cardScores).some(
+          (cardScore) => cardScore.status === "pending_review"
+        );
+        results = await submitAssignmentScore2({
+          assignment: assignmentQuery.data,
+          userId,
+          cardIds: _nullishCoalesce(_optionalChain([setData, 'optionalAccess', _74 => _74.content]), () => ( [])),
+          scores: scoreQuery.data,
+          setWeights: _nullishCoalesce(_optionalChain([setData, 'optionalAccess', _75 => _75.weights]), () => ( {})),
+          status: hasPendingReview ? "PENDING_REVIEW" : "FINALIZED"
+        });
+      } else {
+        results = await submitPracticeScore2({
+          setId: _nullishCoalesce(_optionalChain([querySet, 'access', _76 => _76.data, 'optionalAccess', _77 => _77.id]), () => ( "")),
+          userId,
+          scores: scoreQuery.data
+        });
+      }
+      return results;
+    } catch (error) {
+      return {
+        success: false,
+        error
+      };
+    }
+  };
+  useInitActivity({
+    assignment: _nullishCoalesce(activeAssignment, () => ( void 0)),
+    set: _nullishCoalesce(setData, () => ( void 0)),
+    enabled: !!setData,
+    userId
+  });
+  return {
+    set: {
+      data: setData,
+      query: querySet
+    },
+    cards: {
+      data: cardsObject,
+      query: cardsQueries
+      // activeCardData,
+    },
+    assignment: {
+      data: isAssignment ? activeAssignment : void 0,
+      query: assignmentQuery
+    },
+    scores: {
+      data: scoreQuery.data,
+      query: scoreQuery,
+      // activeCardScores,
+      actions: {
+        update: handleUpdateScore,
+        clear: onClearScore,
+        submit: onSubmitScore,
+        updateCard: handleUpdateCardScore,
+        logGradingStandardEntry: () => {
+        }
+      }
+    }
+  };
+}
+var useInitActivity = ({
+  assignment,
+  set,
+  enabled,
+  userId
+}) => {
+  const { trackActivity } = useActivityTracker({ userId });
+  const init = () => {
+    if (!enabled) return;
+    if (!assignment) {
+      trackActivity({
+        activityName: _nullishCoalesce(_optionalChain([set, 'optionalAccess', _78 => _78.name]), () => ( "")),
+        activityType: "set",
+        id: _optionalChain([set, 'optionalAccess', _79 => _79.id]),
+        language: _optionalChain([set, 'optionalAccess', _80 => _80.language])
+      });
+    } else if (assignment.name) {
+      trackActivity({
+        activityName: assignment.name,
+        activityType: assignment.isAssessment ? "assessment" : "assignment",
+        id: assignment.id,
+        language: _optionalChain([set, 'optionalAccess', _81 => _81.language])
+      });
+    }
+    if (_optionalChain([set, 'optionalAccess', _82 => _82.public])) {
+      _optionalChain([SpeakableFirebaseFunctions, 'optionalAccess', _83 => _83.onSetOpened, 'optionalCall', _84 => _84({
+        setId: set.id,
+        language: set.language
+      })]);
+    }
+    _optionalChain([SpeakableFirebaseFunctions, 'optionalAccess', _85 => _85.updateAlgoliaIndex, 'optionalCall', _86 => _86({
+      updatePlays: true,
+      objectID: _optionalChain([set, 'optionalAccess', _87 => _87.id])
+    })]);
+  };
+  _react.useEffect.call(void 0, () => {
+    init();
+  }, [set]);
+};
+
+
 
 
 
@@ -1005,4 +2067,4 @@ function useSpeakableApi() {
 
 
 
-exports.ALLOWED_CARD_ACTIVITY_TYPES_FOR_SUMMARY = ALLOWED_CARD_ACTIVITY_TYPES_FOR_SUMMARY; exports.BASE_MULTIPLE_CHOICE_FIELD_VALUES = BASE_MULTIPLE_CHOICE_FIELD_VALUES; exports.BASE_REPEAT_FIELD_VALUES = BASE_REPEAT_FIELD_VALUES; exports.BASE_RESPOND_FIELD_VALUES = BASE_RESPOND_FIELD_VALUES; exports.CardActivityType = CardActivityType; exports.FeedbackTypesCard = FeedbackTypesCard; exports.FsCtx = FsCtx; exports.LENIENCY_OPTIONS = LENIENCY_OPTIONS; exports.LeniencyCard = LeniencyCard; exports.MULTIPLE_CHOICE_CARD_ACTIVITY_TYPES = MULTIPLE_CHOICE_CARD_ACTIVITY_TYPES; exports.REPEAT_CARD_ACTIVITY_TYPES = REPEAT_CARD_ACTIVITY_TYPES; exports.RESPOND_AUDIO_CARD_ACTIVITY_TYPES = RESPOND_AUDIO_CARD_ACTIVITY_TYPES; exports.RESPOND_CARD_ACTIVITY_TYPES = RESPOND_CARD_ACTIVITY_TYPES; exports.RESPOND_WRITE_CARD_ACTIVITY_TYPES = RESPOND_WRITE_CARD_ACTIVITY_TYPES; exports.SPEAKABLE_NOTIFICATIONS = SPEAKABLE_NOTIFICATIONS; exports.STUDENT_LEVELS_OPTIONS = STUDENT_LEVELS_OPTIONS; exports.SpeakableNotificationTypes = SpeakableNotificationTypes; exports.SpeakableProvider = SpeakableProvider; exports.VerificationCardStatus = VerificationCardStatus; exports.assignmentQueryKeys = assignmentQueryKeys; exports.cardsQueryKeys = cardsQueryKeys; exports.createAssignmentRepo = createAssignmentRepo; exports.createCardRepo = createCardRepo; exports.createFsClient = createFsClient; exports.createSetRepo = createSetRepo; exports.getCardFromCache = getCardFromCache; exports.getSetFromCache = getSetFromCache; exports.refsCardsFiresotre = refsCardsFiresotre; exports.refsSetsFirestore = refsSetsFirestore; exports.setsQueryKeys = setsQueryKeys; exports.updateCardInCache = updateCardInCache; exports.updateSetInCache = updateSetInCache; exports.useAssignment = useAssignment; exports.useCards = useCards; exports.useCreateCard = useCreateCard; exports.useCreateCards = useCreateCards; exports.useCreateNotification = useCreateNotification; exports.useSet = useSet; exports.useSpeakableApi = useSpeakableApi;
+exports.ALLOWED_CARD_ACTIVITY_TYPES_FOR_SUMMARY = ALLOWED_CARD_ACTIVITY_TYPES_FOR_SUMMARY; exports.BASE_MULTIPLE_CHOICE_FIELD_VALUES = BASE_MULTIPLE_CHOICE_FIELD_VALUES; exports.BASE_REPEAT_FIELD_VALUES = BASE_REPEAT_FIELD_VALUES; exports.BASE_RESPOND_FIELD_VALUES = BASE_RESPOND_FIELD_VALUES; exports.CardActivityType = CardActivityType; exports.FeedbackTypesCard = FeedbackTypesCard; exports.FsCtx = FsCtx; exports.LENIENCY_OPTIONS = LENIENCY_OPTIONS; exports.LeniencyCard = LeniencyCard; exports.MULTIPLE_CHOICE_CARD_ACTIVITY_TYPES = MULTIPLE_CHOICE_CARD_ACTIVITY_TYPES; exports.REPEAT_CARD_ACTIVITY_TYPES = REPEAT_CARD_ACTIVITY_TYPES; exports.RESPOND_AUDIO_CARD_ACTIVITY_TYPES = RESPOND_AUDIO_CARD_ACTIVITY_TYPES; exports.RESPOND_CARD_ACTIVITY_TYPES = RESPOND_CARD_ACTIVITY_TYPES; exports.RESPOND_WRITE_CARD_ACTIVITY_TYPES = RESPOND_WRITE_CARD_ACTIVITY_TYPES; exports.SPEAKABLE_NOTIFICATIONS = SPEAKABLE_NOTIFICATIONS; exports.STUDENT_LEVELS_OPTIONS = STUDENT_LEVELS_OPTIONS; exports.SpeakableNotificationTypes = SpeakableNotificationTypes; exports.SpeakableProvider = SpeakableProvider; exports.VerificationCardStatus = VerificationCardStatus; exports.assignmentQueryKeys = assignmentQueryKeys; exports.cardsQueryKeys = cardsQueryKeys; exports.createAssignmentRepo = createAssignmentRepo; exports.createCardRepo = createCardRepo; exports.createFsClient = createFsClient; exports.createSetRepo = createSetRepo; exports.getCardFromCache = getCardFromCache; exports.getSetFromCache = getSetFromCache; exports.refsCardsFiresotre = refsCardsFiresotre; exports.refsSetsFirestore = refsSetsFirestore; exports.setsQueryKeys = setsQueryKeys; exports.updateCardInCache = updateCardInCache; exports.updateSetInCache = updateSetInCache; exports.useActivity = useActivity; exports.useAssignment = useAssignment; exports.useCards = useCards; exports.useCreateCard = useCreateCard; exports.useCreateCards = useCreateCards; exports.useCreateNotification = useCreateNotification; exports.useSet = useSet; exports.useSpeakableApi = useSpeakableApi;