@speakableio/core 0.1.103 → 0.1.105

package/dist/hooks.cjs

@@ -0,0 +1,1604 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/entry-points/hooks.ts
+var hooks_exports = {};
+__export(hooks_exports, {
+  assignmentQueryKeys: () => assignmentQueryKeys,
+  cardsQueryKeys: () => cardsQueryKeys,
+  getCardFromCache: () => getCardFromCache,
+  getSetFromCache: () => getSetFromCache,
+  scoreQueryKeys: () => scoreQueryKeys,
+  setsQueryKeys: () => setsQueryKeys,
+  updateCardInCache: () => updateCardInCache,
+  updateSetInCache: () => updateSetInCache,
+  useAssignment: () => useAssignment,
+  useCards: () => useCards,
+  useClearScore: () => useClearScore,
+  useCreateCard: () => useCreateCard,
+  useCreateCards: () => useCreateCards,
+  useCreateNotification: () => useCreateNotification,
+  useGetCard: () => useGetCard,
+  useScore: () => useScore,
+  useSet: () => useSet,
+  useSubmitAssignmentScore: () => useSubmitAssignmentScore,
+  useSubmitPracticeScore: () => useSubmitPracticeScore,
+  useUpdateCardScore: () => useUpdateCardScore,
+  useUpdateScore: () => useUpdateScore
+});
+module.exports = __toCommonJS(hooks_exports);
+
+// src/providers/SpeakableProvider.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var FsCtx = (0, import_react.createContext)(null);
+function useSpeakableApi() {
+  const ctx = (0, import_react.useContext)(FsCtx);
+  if (!ctx) throw new Error("useSpeakableApi must be used within a SpeakableProvider");
+  return ctx;
+}
+
+// src/domains/assignment/hooks/assignment.hooks.ts
+var import_react_query = require("@tanstack/react-query");
+var assignmentQueryKeys = {
+  all: ["assignments"],
+  byId: (id) => [...assignmentQueryKeys.all, id],
+  list: () => [...assignmentQueryKeys.all, "list"]
+};
+function useAssignment({
+  assignmentId,
+  enabled = true,
+  analyticType,
+  userId
+}) {
+  const { speakableApi } = useSpeakableApi();
+  return (0, import_react_query.useQuery)({
+    queryKey: assignmentQueryKeys.byId(assignmentId),
+    queryFn: () => speakableApi.assignmentRepo.getAssignment({
+      assignmentId,
+      analyticType,
+      currentUserId: userId
+    }),
+    enabled
+  });
+}
+
+// src/domains/assignment/hooks/score-hooks.ts
+var import_react_query2 = require("@tanstack/react-query");
+
+// 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) => {
+    var _a;
+    return (_a = permissions.permissions) == null ? void 0 : _a.includes(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/lib/firebase/api.ts
+var FirebaseAPI = class _FirebaseAPI {
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  constructor() {
+    this.config = null;
+  }
+  static getInstance() {
+    if (!_FirebaseAPI.instance) {
+      _FirebaseAPI.instance = new _FirebaseAPI();
+    }
+    return _FirebaseAPI.instance;
+  }
+  initialize(config) {
+    this.config = config;
+  }
+  get db() {
+    if (!this.config) throw new Error("Firebase API not initialized");
+    return this.config.db;
+  }
+  get helpers() {
+    if (!this.config) throw new Error("Firebase API not initialized");
+    return this.config.helpers;
+  }
+  get httpsCallable() {
+    var _a;
+    return (_a = this.config) == null ? void 0 : _a.httpsCallable;
+  }
+  logEvent(name, data) {
+    var _a;
+    (_a = this.config) == null ? void 0 : _a.logEvent(name, data);
+  }
+  accessQueryConstraints() {
+    const { query, orderBy, limit, startAt, startAfter, endAt, endBefore, where, increment } = this.helpers;
+    return {
+      query,
+      orderBy,
+      limit,
+      startAt,
+      startAfter,
+      endAt,
+      endBefore,
+      where,
+      increment
+    };
+  }
+  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() ? {
+      ...docSnap.data(),
+      id: docSnap.id
+    } : null;
+    return {
+      id: docSnap.id,
+      data
+    };
+  }
+  async getDocs(path, ...queryConstraints) {
+    const { getDocs, query, collection } = this.helpers;
+    const collectionRef = collection(this.db, path);
+    const q = queryConstraints.length > 0 ? query(collectionRef, ...queryConstraints) : collectionRef;
+    const querySnapshot = await getDocs(q);
+    const data = querySnapshot.docs.map((doc) => ({
+      data: doc.data(),
+      id: doc.id
+    }));
+    return {
+      data,
+      querySnapshot,
+      empty: querySnapshot.empty
+    };
+  }
+  async addDoc(path, data) {
+    const { addDoc, collection } = this.helpers;
+    const collectionRef = collection(this.db, path);
+    const docRef = await addDoc(collectionRef, data);
+    return {
+      ...data,
+      id: docRef.id
+    };
+  }
+  async setDoc(path, data, options = {}) {
+    const { setDoc, doc } = this.helpers;
+    const docRef = doc(this.db, path);
+    await setDoc(docRef, data, options);
+  }
+  async updateDoc(path, data) {
+    const { updateDoc, doc } = this.helpers;
+    const docRef = doc(this.db, path);
+    await updateDoc(docRef, data);
+  }
+  async deleteDoc(path) {
+    const { deleteDoc, doc } = this.helpers;
+    const docRef = doc(this.db, path);
+    await deleteDoc(docRef);
+  }
+  async runTransaction(updateFunction) {
+    const { runTransaction } = this.helpers;
+    return runTransaction(this.db, updateFunction);
+  }
+  async runBatch(operations) {
+    const { writeBatch } = this.helpers;
+    const batch = writeBatch(this.db);
+    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();
+
+// src/hooks/useGoogleClassroom.ts
+var useGoogleClassroom = () => {
+  const submitAssignmentToGoogleClassroom = async ({
+    assignment,
+    scores,
+    googleUserId = null
+    // optional to override the user's googleUserId
+  }) => {
+    var _a, _b, _c;
+    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 = (scores == null ? void 0 : scores.score) ? (scores == null ? void 0 : scores.score) / 100 * maxPoints : 0;
+      const result = await ((_c = (_b = (_a = api).httpsCallable) == null ? void 0 : _b.call(_a, "submitAssignmentToGoogleClassroomV2")) == null ? void 0 : _c({
+        teacherId: owners[0],
+        courseId,
+        courseWorkId,
+        userId: googleId,
+        draftGrade
+      }));
+      return result;
+    } catch (error) {
+      return { error: true, message: error.message };
+    }
+  };
+  return {
+    submitAssignmentToGoogleClassroom
+  };
+};
+
+// src/constants/analytics.constants.ts
+var ANALYTICS_EVENT_TYPES = {
+  VOICE_SUCCESS: "voice_success",
+  VOICE_FAIL: "voice_fail",
+  RESPOND_CARD_SUCCESS: "respond_card_success",
+  RESPOND_CARD_FAIL: "respond_card_fail",
+  RESPOND_WRITE_CARD_SUCCESS: "respond_write_card_success",
+  RESPOND_WRITE_CARD_FAIL: "respond_write_card_fail",
+  RESPOND_WRITE_CARD_SUBMITTED: "respond_write_card_submitted",
+  RESPOND_WRITE_CARD_ERROR: "respond_write_card_error",
+  RESPOND_CARD_ERROR: "respond_card_error",
+  RESPOND_CARD_SUBMITTED: "respond_card_submitted",
+  RESPOND_FREE_PLAN: "respond_free_plan",
+  RESPOND_WRITE_FREE_PLAN: "respond_write_free_plan",
+  SUBMISSION: "assignment_submitted",
+  ASSIGNMENT_STARTED: "assignment_started",
+  CREATE_ASSIGNMENT: "create_assignment",
+  MC_SUCCESS: "multiple_choice_success",
+  MC_FAIL: "multiple_choice_fail",
+  MC_ERROR: "multiple_choice_error",
+  ACTFL_LEVEL: "actfl_level",
+  WIDA_LEVEL: "wida_level"
+};
+
+// src/lib/firebase/firebase-analytics/assignment.ts
+var logSubmitAssignment = (data = {}) => {
+  var _a, _b, _c;
+  (_c = (_b = (_a = api).httpsCallable) == null ? void 0 : _b.call(_a, "handleCouresAnalyticsEvent")) == null ? void 0 : _c({
+    eventType: ANALYTICS_EVENT_TYPES.SUBMISSION,
+    ...data
+  });
+  api.logEvent(ANALYTICS_EVENT_TYPES.SUBMISSION, data);
+};
+var logStartAssignment = (data = {}) => {
+  var _a, _b, _c;
+  if (data.courseId) {
+    (_c = (_b = (_a = api).httpsCallable) == null ? void 0 : _b.call(_a, "handleCouresAnalyticsEvent")) == null ? void 0 : _c({
+      eventType: ANALYTICS_EVENT_TYPES.ASSIGNMENT_STARTED,
+      ...data
+    });
+  }
+  api.logEvent(ANALYTICS_EVENT_TYPES.ASSIGNMENT_STARTED, data);
+};
+
+// src/domains/notification/services/create-notification.service.ts
+var import_dayjs = __toESM(require("dayjs"));
+
+// src/constants/web.constants.ts
+var WEB_BASE_URL = "https://app.speakable.io";
+
+// 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/utils/error-handler.ts
+var ServiceError = class extends Error {
+  constructor(message, originalError, code) {
+    super(message);
+    this.originalError = originalError;
+    this.code = code;
+    this.name = "ServiceError";
+  }
+};
+function withErrorHandler(fn, serviceName) {
+  return async (...args) => {
+    try {
+      return await fn(...args);
+    } catch (error) {
+      if (error instanceof Error && "code" in error) {
+        const firebaseError = error;
+        throw new ServiceError(
+          `Error in ${serviceName}: ${firebaseError.message}`,
+          error,
+          firebaseError.code
+        );
+      }
+      if (error instanceof Error) {
+        throw new ServiceError(`Error in ${serviceName}: ${error.message}`, error);
+      }
+      throw new ServiceError(`Unknown error in ${serviceName}`, error);
+    }
+  };
+}
+
+// src/domains/notification/services/send-notification.service.ts
+var _sendNotification = async (sendTo, notification) => {
+  var _a, _b, _c;
+  const results = await ((_c = (_b = (_a = api).httpsCallable) == null ? void 0 : _b.call(_a, "createNotificationV2")) == null ? void 0 : _c({
+    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
+}) => {
+  var _a;
+  const { assignment, sendTo } = data;
+  const teacherName = profile.displayName || "Your teacher";
+  const dueDate = assignment.dueDateTimestamp ? (0, import_dayjs.default)(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: (_a = profile.image) == null ? void 0 : _a.url
+  });
+  return results;
+};
+var createAssessmentSubmissionNotification = async ({
+  data: assignment,
+  profile,
+  userId
+}) => {
+  var _a;
+  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: (_a = profile.image) == null ? void 0 : _a.url
+  });
+  return results;
+};
+var createAssessmentScoredNotification = async ({
+  data,
+  profile
+}) => {
+  var _a, _b, _c, _d, _e;
+  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: (_a = profile.image) == null ? void 0 : _a.url,
+    senderName: teacherName
+  });
+  await ((_e = (_c = (_b = api).httpsCallable) == null ? void 0 : _c.call(_b, "sendAssessmentScoredEmail")) == null ? void 0 : _e({
+    assessmentTitle: assignment.name,
+    link: `${WEB_BASE_URL}/assignment/${assignment.id}`,
+    senderImage: ((_d = profile.image) == null ? void 0 : _d.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) => {
+    var _a, _b;
+    const result = await createNotification({
+      type,
+      userId: user.auth.uid,
+      profile: (_a = user == null ? void 0 : user.profile) != null ? _a : {},
+      data
+    });
+    queryClient.invalidateQueries({
+      queryKey: notificationQueryKeys.byId((_b = user == null ? void 0 : user.auth.uid) != null ? _b : "")
+    });
+    return result;
+  };
+  return {
+    createNotification: handleCreateNotifications
+  };
+};
+
+// src/domains/assignment/assignment.constants.ts
+var ASSIGNMENTS_COLLECTION = "assignments";
+var ANALYTICS_SUBCOLLECTION = "analytics";
+var SCORES_SUBCOLLECTION = "scores";
+var refsAssignmentFiresotre = {
+  allAssignments: () => ASSIGNMENTS_COLLECTION,
+  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/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) {
+  var _a, _b, _c;
+  if (params.isAssignment) {
+    const ref = refsAssignmentFiresotre.assignmentScores({
+      id: params.activityId,
+      userId: params.userId
+    });
+    await ((_c = (_b = (_a = api).httpsCallable) == null ? void 0 : _b.call(_a, "updateAssignmentGradebookStatus")) == null ? void 0 : _c({
+      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
+    };
+    logStartAssignment({
+      courseId: assignment.courseId
+    });
+    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 += (weights == null ? void 0 : weights[cardId]) || 1;
+    return acc;
+  }, 0);
+  const totalPointsAwarded = Object.keys((scores == null ? void 0 : scores.cards) || {}).reduce((acc, cardId) => {
+    var _a, _b;
+    const cardScores = (_a = scores == null ? void 0 : scores.cards) == null ? void 0 : _a[cardId];
+    if ((cardScores == null ? void 0 : cardScores.completed) || (cardScores == null ? void 0 : cardScores.score) || (cardScores == null ? void 0 : cardScores.score) === 0) {
+      const score2 = (cardScores == null ? void 0 : cardScores.score) || (cardScores == null ? void 0 : cardScores.score) === 0 ? Number((_b = cardScores == null ? void 0 : cardScores.score) != null ? _b : 0) : null;
+      const weight = (weights == null ? void 0 : weights[cardId]) || 1;
+      const fraction = (score2 != null ? score2 : 0) / 100;
+      if (score2 || score2 === 0) {
+        acc += weight * fraction;
+      } else {
+        acc += weight;
+      }
+    }
+    return acc;
+  }, 0);
+  const totalCompletedCards = Object.keys((scores == null ? void 0 : scores.cards) || {}).reduce((acc, cardId) => {
+    var _a;
+    const cardScores = (_a = scores == null ? void 0 : scores.cards) == null ? void 0 : _a[cardId];
+    if ((cardScores == null ? void 0 : cardScores.completed) || (cardScores == null ? void 0 : cardScores.score) || (cardScores == null ? void 0 : cardScores.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
+var import_dayjs2 = __toESM(require("dayjs"));
+async function clearScore(params) {
+  var _a, _b, _c, _d, _e;
+  const update = {
+    [`cards.${params.cardId}`]: {
+      attempts: ((_a = params.cardScores.attempts) != null ? _a : 1) + 1,
+      correct: (_b = params.cardScores.correct) != null ? _b : 0,
+      // save old score history
+      history: [
+        {
+          ...params.cardScores,
+          attempts: (_c = params.cardScores.attempts) != null ? _c : 1,
+          correct: (_d = params.cardScores.correct) != null ? _d : 0,
+          retryTime: (0, import_dayjs2.default)().format("YYYY-MM-DD HH:mm:ss"),
+          history: null
+        },
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        ...(_e = params.cardScores.history) != null ? _e : []
+      ]
+    }
+  };
+  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
+var import_dayjs3 = __toESM(require("dayjs"));
+async function _submitAssignmentScore({
+  cardIds,
+  assignment,
+  weights,
+  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,
+      weights,
+      fieldsUpdated,
+      studentName
+    );
+    return result;
+  } else if (assignment.courseId) {
+    await handleCourseAssignment(assignment, userId);
+  }
+  await api.updateDoc(path, { ...fieldsUpdated });
+  return { success: true, fieldsUpdated };
+}
+var submitAssignmentScore = withErrorHandler(
+  _submitAssignmentScore,
+  "submitAssignmentScore"
+);
+async function handleAssessment(assignment, userId, cardIds, weights, fieldsUpdated, studentName) {
+  var _a, _b, _c;
+  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, weights);
+  await api.updateDoc(path, { score: scoreCalculated, status: "PENDING_REVIEW" });
+  await ((_c = (_b = (_a = api).httpsCallable) == null ? void 0 : _b.call(_a, "submitAssessment")) == null ? void 0 : _c({
+    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) {
+  var _a, _b, _c;
+  await ((_c = (_b = (_a = api).httpsCallable) == null ? void 0 : _b.call(_a, "submitAssignmentV2")) == null ? void 0 : _c({
+    assignmentId: assignment.id,
+    userId
+  }));
+}
+async function submitPracticeScore({
+  setId,
+  userId,
+  scores
+}) {
+  const { serverTimestamp } = api.accessHelpers();
+  const date = (0, import_dayjs3.default)().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 (0, import_react_query2.useQuery)({
+    queryFn: () => getScore({
+      userId,
+      courseId,
+      activityId,
+      googleClassroomUserId,
+      isAssignment
+    }),
+    queryKey: scoreQueryKeys.byId(activityId),
+    enabled
+  });
+}
+var debounceUpdateScore = debounce(updateScore, 1e3);
+function useUpdateScore() {
+  const { queryClient } = useSpeakableApi();
+  const mutation = (0, import_react_query2.useMutation)({
+    mutationFn: debounceUpdateScore,
+    onMutate: (variables) => {
+      return handleOptimisticUpdate({
+        queryClient,
+        queryKey: scoreQueryKeys.byId(variables.activityId),
+        newData: variables.data
+      });
+    },
+    onError: (_, variables, context) => {
+      if (context == null ? void 0 : context.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,
+  cardIds,
+  weights
+}) {
+  const { queryClient } = useSpeakableApi();
+  const queryKey = scoreQueryKeys.byId(activityId);
+  const mutation = (0, import_react_query2.useMutation)({
+    mutationFn: async ({ cardId, cardScore }) => {
+      const previousScores = queryClient.getQueryData(queryKey);
+      const { progress, score, newScoreUpdated, updatedCardScore } = getScoreUpdated({
+        previousScores: previousScores != null ? previousScores : {},
+        cardId,
+        cardScore,
+        cardIds,
+        weights
+      });
+      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,
+          cardIds,
+          weights
+        });
+        return {
+          ...previousScore,
+          ...updates
+        };
+      });
+    },
+    // eslint-disable-next-line no-unused-vars
+    onError: (error) => {
+      console.log(error.message);
+      const previousData = queryClient.getQueryData(queryKey);
+      if (previousData) {
+        queryClient.setQueryData(queryKey, previousData);
+      }
+    }
+  });
+  return {
+    mutationUpdateCardScore: mutation
+  };
+}
+var getScoreUpdated = ({
+  cardId,
+  cardScore,
+  previousScores,
+  cardIds,
+  weights
+}) => {
+  var _a, _b;
+  const previousCard = (_a = previousScores.cards) == null ? void 0 : _a[cardId];
+  const newCardScore = {
+    ...previousCard != null ? previousCard : {},
+    ...cardScore
+  };
+  const newScores = {
+    ...previousScores,
+    cards: {
+      ...(_b = previousScores.cards) != null ? _b : {},
+      [cardId]: newCardScore
+    }
+  };
+  const { score, progress } = calculateScoreAndProgress_default(newScores, cardIds, weights);
+  return {
+    newScoreUpdated: newScores,
+    updatedCardScore: cardScore,
+    score,
+    progress
+  };
+};
+var handleOptimisticScore = ({
+  score,
+  cardId,
+  cardScore,
+  cardIds,
+  weights
+}) => {
+  var _a;
+  let cards = { ...(_a = score == null ? void 0 : score.cards) != null ? _a : {} };
+  cards = {
+    ...cards,
+    [cardId]: {
+      ...cards[cardId],
+      ...cardScore
+    }
+  };
+  const { score: scoreValue, progress } = calculateScoreAndProgress_default(
+    // @ts-ignore
+    {
+      ...score != null ? score : {},
+      cards
+    },
+    cardIds,
+    weights
+  );
+  return { cards, score: scoreValue, progress };
+};
+function useClearScore() {
+  const { queryClient } = useSpeakableApi();
+  const mutation = (0, import_react_query2.useMutation)({
+    mutationFn: clearScore,
+    onSettled: (result) => {
+      var _a;
+      queryClient.invalidateQueries({
+        queryKey: scoreQueryKeys.byId((_a = result == null ? void 0 : result.activityId) != null ? _a : "")
+      });
+    }
+  });
+  return {
+    mutationClearScore: mutation
+  };
+}
+function useSubmitAssignmentScore({
+  onAssignmentSubmitted,
+  studentName
+}) {
+  const { queryClient } = useSpeakableApi();
+  const { hasGoogleClassroomGradePassback } = usePermissions_default();
+  const { submitAssignmentToGoogleClassroom } = useGoogleClassroom();
+  const { createNotification: createNotification2 } = useCreateNotification();
+  const mutation = (0, import_react_query2.useMutation)({
+    mutationFn: async ({
+      assignment,
+      userId,
+      cardIds,
+      weights,
+      scores,
+      status
+    }) => {
+      try {
+        const scoreUpdated = await submitAssignmentScore({
+          assignment,
+          userId,
+          cardIds,
+          weights,
+          status,
+          studentName
+        });
+        if (assignment.courseWorkId != null && !assignment.isAssessment && hasGoogleClassroomGradePassback) {
+          await submitAssignmentToGoogleClassroom({
+            assignment,
+            scores
+          });
+        }
+        if (assignment.isAssessment) {
+          createNotification2(SpeakableNotificationTypes.ASSESSMENT_SUBMITTED, assignment);
+        }
+        if (assignment == null ? void 0 : assignment.id) {
+          logSubmitAssignment({
+            courseId: assignment == null ? void 0 : assignment.courseId
+          });
+        }
+        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 = (0, import_react_query2.useMutation)({
+    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/domains/cards/card.hooks.ts
+var import_react_query3 = require("@tanstack/react-query");
+var import_react2 = require("react");
+
+// src/domains/cards/card.constants.ts
+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
+var import_uuid = require("uuid");
+
+// src/utils/text-utils.ts
+var import_js_sha1 = __toESM(require("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 == null ? void 0 : 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 = (0, import_js_sha1.default)(`${language}-${cleanedWord}`);
+  console.log("wordHash core library", wordHash);
+  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 == null ? void 0 : 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 = (0, import_uuid.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 = (0, import_react_query3.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 = (0, import_react2.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 = (0, import_react_query3.useMutation)({
+    mutationFn: createCard,
+    onSuccess: (cardCreated) => {
+      queryClient.invalidateQueries({ queryKey: cardsQueryKeys.one({ cardId: cardCreated.id }) });
+    }
+  });
+  return {
+    mutationCreateCard
+  };
+}
+function useCreateCards() {
+  const mutationCreateCards = (0, import_react_query3.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);
+}
+function useGetCard({ cardId, enabled = true }) {
+  const query = (0, import_react_query3.useQuery)({
+    queryKey: cardsQueryKeys.one({ cardId }),
+    queryFn: () => getCard({ cardId }),
+    enabled: enabled && !!cardId
+  });
+  return query;
+}
+
+// src/domains/sets/set.hooks.ts
+var import_react_query4 = require("@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 (0, import_react_query4.useQuery)({
+    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);
+}
+//# sourceMappingURL=hooks.cjs.map