@magmamath/students-features 1.3.23-rc.21 → 1.3.23-rc.3

package/src/features/translation/providers/google/supportedLanguages.ts

@@ -1,229 +0,0 @@
-const SUPPORTED_CODES = new Set<string>()
-const NAME_TO_CODE: Record<string, string> = {}
-
-const normalizeLanguageName = (language: string): string =>
-  language
-    .trim()
-    .toUpperCase()
-    .replace(/[\s()-]+/g, '_')
-
-/**
- * Resolves an arbitrary language input (ISO code, locale, or English name) to the
- * Google Translate ISO code. Returns null when the language is not supported.
- *
- * Examples:
- *   "en"         → "en"
- *   "en-SE"      → "en"  (base fallback)
- *   "zh-CN"      → "zh-CN" (exact match)
- *   "Spanish"    → "es"  (name lookup)
- *   "Chinese Simplified" → "zh-CN"
- */
-export const resolveGoogleLanguageCode = (language?: string | null): string | null => {
-  if (!language) return null
-  if (SUPPORTED_CODES.has(language)) return language
-  const base = language.split('-')[0]
-  if (base !== language && SUPPORTED_CODES.has(base)) return base
-  return NAME_TO_CODE[normalizeLanguageName(language)] ?? null
-}
-
-export const GoogleTranslateLanguage = {
-  ABKHAZ: 'ab',
-  ACEHNESE: 'ace',
-  ACHOLI: 'ach',
-  AFRIKAANS: 'af',
-  ALBANIAN: 'sq',
-  ALUR: 'alz',
-  AMHARIC: 'am',
-  ARABIC: 'ar',
-  ARMENIAN: 'hy',
-  ASSAMESE: 'as',
-  AWADHI: 'awa',
-  AYMARA: 'ay',
-  AZERBAIJANI: 'az',
-  BALINESE: 'ban',
-  BAMBARA: 'bm',
-  BASHKIR: 'ba',
-  BASQUE: 'eu',
-  BATAK_KARO: 'btx',
-  BATAK_SIMALUNGUN: 'bts',
-  BATAK_TOBA: 'bbc',
-  BELARUSIAN: 'be',
-  BEMBA: 'bem',
-  BENGALI: 'bn',
-  BETAWI: 'bew',
-  BHOJPURI: 'bho',
-  BIKOL: 'bik',
-  BOSNIAN: 'bs',
-  BRETON: 'br',
-  BULGARIAN: 'bg',
-  BURMESE: 'my',
-  BURYAT: 'bua',
-  CANTONESE: 'yue',
-  CATALAN: 'ca',
-  CEBUANO: 'ceb',
-  CHICHEWA_NYANJA: 'ny',
-  CHINESE_SIMPLIFIED: 'zh-CN',
-  CHINESE_TRADITIONAL: 'zh-TW',
-  CHUVASH: 'cv',
-  CORSICAN: 'co',
-  CRIMEAN_TATAR: 'crh',
-  CROATIAN: 'hr',
-  CZECH: 'cs',
-  DANISH: 'da',
-  DINKA: 'din',
-  DIVEHI: 'dv',
-  DOGRI: 'doi',
-  DOMBE: 'dov',
-  DUTCH: 'nl',
-  DZONGKHA: 'dz',
-  ENGLISH: 'en',
-  ESPERANTO: 'eo',
-  ESTONIAN: 'et',
-  EWE: 'ee',
-  FIJIAN: 'fj',
-  FILIPINO_TAGALOG: 'fil',
-  FINNISH: 'fi',
-  FRENCH: 'fr',
-  FRENCH_CANADA: 'fr-CA',
-  FRENCH_FRANCE: 'fr-FR',
-  FRISIAN: 'fy',
-  FULFULDE: 'ff',
-  GA: 'gaa',
-  GALICIAN: 'gl',
-  GANDA_LUGANDA: 'lg',
-  GEORGIAN: 'ka',
-  GERMAN: 'de',
-  GREEK: 'el',
-  GUARANI: 'gn',
-  GUJARATI: 'gu',
-  HAITIAN_CREOLE: 'ht',
-  HAKHA_CHIN: 'cnh',
-  HAUSA: 'ha',
-  HAWAIIAN: 'haw',
-  HEBREW: 'he',
-  HILIGAYNON: 'hil',
-  HINDI: 'hi',
-  HMONG: 'hmn',
-  HUNGARIAN: 'hu',
-  HUNSRIK: 'hrx',
-  ICELANDIC: 'is',
-  IGBO: 'ig',
-  ILOKO: 'ilo',
-  INDONESIAN: 'id',
-  IRISH: 'ga',
-  ITALIAN: 'it',
-  JAPANESE: 'ja',
-  JAVANESE: 'jw',
-  KANNADA: 'kn',
-  KAPAMPANGAN: 'pam',
-  KAZAKH: 'kk',
-  KHMER: 'km',
-  KIGA: 'cgg',
-  KINYARWANDA: 'rw',
-  KITUBA: 'ktu',
-  KONKANI: 'gom',
-  KOREAN: 'ko',
-  KRIO: 'kri',
-  KURMANJI: 'ku',
-  KYRGYZ: 'ky',
-  LAO: 'lo',
-  LATGALIAN: 'ltg',
-  LATIN: 'la',
-  LATVIAN: 'lv',
-  LIGURIAN: 'lij',
-  LIMBURGAN: 'li',
-  LINGALA: 'ln',
-  LITHUANIAN: 'lt',
-  LOMBARD: 'lmo',
-  LUO: 'luo',
-  LUXEMBOURGISH: 'lb',
-  MACEDONIAN: 'mk',
-  MAITHILI: 'mai',
-  MAKASSAR: 'mak',
-  MALAGASY: 'mg',
-  MALAY: 'ms',
-  MALAYALAM: 'ml',
-  MALAY_JAWI: 'ms-Arab',
-  MALTESE: 'mt',
-  MAORI: 'mi',
-  MARATHI: 'mr',
-  MEADOW_MARI: 'chm',
-  MEITEILON_MANIPURI: 'mni-Mtei',
-  MINANG: 'min',
-  MIZO: 'lus',
-  MONGOLIAN: 'mn',
-  NDEBELE_SOUTH: 'nr',
-  NEPALBHASA_NEWARI: 'new',
-  NEPALI: 'ne',
-  NORTHERN_SOTHO: 'nso',
-  NORWEGIAN: 'no',
-  NUER: 'nus',
-  OCCITAN: 'oc',
-  ODIA: 'or',
-  OROMO: 'om',
-  PANGASINAN: 'pag',
-  PAPIAMENTO: 'pap',
-  PASHTO: 'ps',
-  PERSIAN: 'fa',
-  POLISH: 'pl',
-  PORTUGUESE: 'pt',
-  PORTUGUESE_BRAZIL: 'pt-BR',
-  PORTUGUESE_PORTUGAL: 'pt-PT',
-  PUNJABI: 'pa',
-  PUNJABI_SHAHMUKHI: 'pa-Arab',
-  QUECHUA: 'qu',
-  ROMANI: 'rom',
-  ROMANIAN: 'ro',
-  RUNDI: 'rn',
-  RUSSIAN: 'ru',
-  SAMOAN: 'sm',
-  SANGO: 'sg',
-  SANSKRIT: 'sa',
-  SCOTS_GAELIC: 'gd',
-  SERBIAN: 'sr',
-  SESOTHO: 'st',
-  SEYCHELLOIS_CREOLE: 'crs',
-  SHAN: 'shn',
-  SHONA: 'sn',
-  SICILIAN: 'scn',
-  SILESIAN: 'szl',
-  SINDHI: 'sd',
-  SINHALA: 'si',
-  SLOVAK: 'sk',
-  SLOVENIAN: 'sl',
-  SOMALI: 'so',
-  SORANI: 'ckb',
-  SPANISH: 'es',
-  SUNDANESE: 'su',
-  SWAHILI: 'sw',
-  SWATI: 'ss',
-  SWEDISH: 'sv',
-  TAJIK: 'tg',
-  TAMIL: 'ta',
-  TATAR: 'tt',
-  TELUGU: 'te',
-  TETUM: 'tet',
-  THAI: 'th',
-  TIGRINYA: 'ti',
-  TSONGA: 'ts',
-  TSWANA: 'tn',
-  TURKISH: 'tr',
-  TURKMEN: 'tk',
-  TWI_AKAN: 'ak',
-  UKRAINIAN: 'uk',
-  URDU: 'ur',
-  UYGHUR: 'ug',
-  UZBEK: 'uz',
-  VIETNAMESE: 'vi',
-  WELSH: 'cy',
-  XHOSA: 'xh',
-  YIDDISH: 'yi',
-  YORUBA: 'yo',
-  YUCATEC_MAYA: 'yua',
-  ZULU: 'zu',
-}
-
-Object.entries(GoogleTranslateLanguage).forEach(([name, code]) => {
-  SUPPORTED_CODES.add(code)
-  NAME_TO_CODE[name] = code
-})

package/src/features/translation/providers/google.types.ts

@@ -1,16 +0,0 @@
-export type GoogleTranslateProps = {
-  text: string[]
-  targetLanguage: string
-  sourceLanguage?: string
-}
-
-export type GoogleTranslation = {
-  translatedText: string
-  detectedSourceLanguage: string
-}
-
-export type GoogleTranslateResponse = {
-  data: {
-    translations: GoogleTranslation[]
-  }
-}

package/src/features/translation/providers/translation.interface.ts

@@ -1,63 +0,0 @@
-import { replaceMappedTokens } from '../helpers'
-
-export type LanguageGlossary = {
-  [languageCode: string]: Record<string, string>
-}
-
-type TranslationProviderProps = {
-  supportedLanguages: string[]
-  glossaries?: LanguageGlossary
-}
-
-export abstract class TranslationProvider {
-  protected readonly supportedLanguages: ReadonlySet<string>
-  protected readonly glossaries: LanguageGlossary = {}
-
-  protected constructor({ supportedLanguages, glossaries = {} }: TranslationProviderProps) {
-    this.supportedLanguages = new Set(supportedLanguages)
-    this.glossaries = glossaries
-  }
-
-  public abstract request(
-    text: string,
-    targetLanguage: string,
-    sourceLanguage?: string,
-  ): Promise<string>
-  public abstract requestBatch(
-    text: string[],
-    targetLanguage: string,
-    sourceLanguage?: string,
-  ): Promise<string[]>
-
-  public isTargetSupported(language: string) {
-    return this.resolveLanguage(language) !== null
-  }
-
-  /**
-   * Returns the provider-supported variant of `language`, falling back to the base
-   * language part (e.g. "en-SE" → "en") when the exact locale is not listed.
-   * Subclasses may override to add their own resolution (e.g. language names).
-   * Returns null when the language cannot be resolved.
-   */
-  public resolveLanguage(language: string): string | null {
-    if (!language) return null
-    if (this.supportedLanguages.has(language)) return language
-    const base = language.split('-')[0]
-    if (base !== language && this.supportedLanguages.has(base)) return base
-    return null
-  }
-
-  public getSupportedLanguages() {
-    return this.supportedLanguages.values()
-  }
-
-  /**
-   * Replaces full standalone words in text using a custom glossary for the target language,
-   * matching words like "Hello", or "Hej" regardless of case, but not when they appear inside other words.
-   */
-  public applyGlossary(text: string, targetLanguage: string): string {
-    const glossary = this.glossaries[targetLanguage]
-    if (!glossary) return text
-    return replaceMappedTokens(text, glossary)
-  }
-}

package/src/features/translation/types.ts

@@ -1,30 +0,0 @@
-export type TranslatableProblem = {
-  description: string
-  richDescription?: string
-  answerVariants: string[]
-}
-
-export type TranslateAllFxParams<TProblem extends TranslatableProblem = TranslatableProblem> = {
-  problem: TProblem | null
-  translationLanguageCode?: string | null
-}
-
-export type TranslateFxParams = {
-  cacheKey: string
-  text: string
-}
-
-export type Replacement = {
-  placeholder: string
-  original: string
-  leftPad?: boolean
-  rightPad?: boolean
-}
-
-export type MaskSegmentParams = {
-  text: string
-  regex: RegExp
-  placeholder: string
-  replacements: Replacement[]
-  shouldSkip?: (match: string) => boolean
-}

package/src/features/voice/playing/hooks/useVoiceTranscriptionController.ts

@@ -1,171 +0,0 @@
-import { useUnit } from 'effector-react'
-import { useCallback, useEffect, useMemo, useRef } from 'react'
-import { useTranslation } from 'react-i18next'
-import { NO_AUDIO_BE_MESSAGE } from '../../constants'
-import { getActiveAttempt } from '../../helpers'
-import { AnswerAudio } from '../../types'
-import { resolveGoogleLanguageCode } from '../../../translation/providers/google/supportedLanguages'
-import { useText } from '../../../../i18n/i18n'
-import { VoicePlayerModel } from '../model'
-import { PlayerState } from '../model/Player.model'
-
-type Params = {
-  model: VoicePlayerModel
-  answers: AnswerAudio[]
-  attemptOffset: number
-  attemptsCount: number
-  problemId: string
-}
-
-export type VoiceTranscriptionController = ReturnType<typeof useVoiceTranscriptionController>
-
-export const useVoiceTranscriptionController = ({
-  model,
-  answers,
-  attemptOffset,
-  attemptsCount,
-  problemId,
-}: Params) => {
-  const t = useText()
-  const { i18n } = useTranslation()
-
-  const [playerState, isLoadingTranscripts, isTranslationActive, translations, isTranslating] =
-    useUnit([
-      model.$playerState,
-      model.loader.loadTranscriptForAttempt.pending,
-      model.translation.$isActive,
-      model.translation.$translations,
-      model.translation.translate.pending,
-    ])
-
-  const activeAttempt = getActiveAttempt(attemptOffset, attemptsCount)
-
-  const answersKey = useMemo(
-    () => answers.map((a) => `${a._id}:${a.audioFileId ?? ''}`).join(','),
-    [answers],
-  )
-
-  const activeAudioFileId =
-    activeAttempt !== null ? answers?.[activeAttempt - 1]?.audioFileId : undefined
-  const hasActiveAudio = activeAudioFileId !== undefined
-  const anyAttemptHasAudio = useMemo(() => answers.some((a) => !!a.audioFileId), [answers])
-
-  const cachedEntry = activeAudioFileId
-    ? model.loader.getCachedTranscript(activeAudioFileId)
-    : undefined
-  const activeTranscript = cachedEntry?.text ?? null
-  const hasTranscriptText = !!activeTranscript && activeTranscript !== NO_AUDIO_BE_MESSAGE
-  const isActiveTranscriptLoading = isLoadingTranscripts && hasActiveAudio && !activeTranscript
-
-  const isSourceSameAsTarget =
-    !!cachedEntry?.language &&
-    resolveGoogleLanguageCode(cachedEntry.language) === resolveGoogleLanguageCode(i18n.language)
-
-  const canTranslate = hasTranscriptText && !isSourceSameAsTarget
-
-  const cachedTranslation = activeAttempt !== null ? translations[activeAttempt] : undefined
-  const showTranslation = isTranslationActive && canTranslate
-  const isTranslationLoading = showTranslation && !cachedTranslation && isTranslating
-
-  const displayText = showTranslation
-    ? (cachedTranslation ?? activeTranscript!)
-    : hasTranscriptText
-      ? activeTranscript!
-      : t('voice.transcriptNotAvailable')
-
-  // Lifecycle effects
-  const answersRef = useRef(answers)
-  answersRef.current = answers
-
-  useEffect(() => {
-    model.reinitializePlayer()
-    return () => {
-      model.stopAudio()
-      model.dropdown.setExpanded(false)
-    }
-  }, [model])
-
-  useEffect(() => {
-    model.dropdown.setExpanded(false)
-    model.resetPlayer()
-  }, [problemId])
-
-  useEffect(() => {
-    if (answersRef.current.some((a) => a.audioFileId)) {
-      model.initializeWithAudios(answersRef.current)
-    }
-  }, [model, answersKey])
-
-  useEffect(() => {
-    model.stopAudio()
-    model.setCurrentAttempt(activeAttempt)
-    if (activeAttempt !== null) {
-      model.loader.loadTranscriptForAttempt(activeAttempt)
-    }
-  }, [model, activeAttempt, answersKey])
-
-  // Auto-activate translation once per (problemId, activeAttempt) when translatable
-  const autoActivatedAttempts = useRef(new Set<number>())
-  useEffect(() => {
-    autoActivatedAttempts.current.clear()
-  }, [problemId])
-  useEffect(() => {
-    if (
-      canTranslate &&
-      activeAttempt !== null &&
-      !autoActivatedAttempts.current.has(activeAttempt)
-    ) {
-      autoActivatedAttempts.current.add(activeAttempt)
-      model.translation.setActive(true)
-    }
-  }, [canTranslate, activeAttempt, model])
-
-  // Trigger translate when we should show translation but don't have it cached
-  useEffect(() => {
-    if (showTranslation && activeAttempt !== null && !cachedTranslation && !isTranslating) {
-      model.translation.translate({
-        attemptNumber: activeAttempt,
-        targetLanguage: i18n.language,
-      })
-    }
-  }, [showTranslation, activeAttempt, cachedTranslation, isTranslating, i18n.language, model])
-
-  // Auto-open dropdown when a translation successfully completes
-  useEffect(() => {
-    return model.translation.translate.doneData.watch((result) => {
-      if (result) {
-        model.dropdown.setExpanded(true)
-      }
-    })
-  }, [model])
-
-  const onPlayPress = useCallback(() => {
-    if (activeAttempt) {
-      model.translation.setActive(false)
-      model.togglePlayPause(activeAttempt)
-    }
-  }, [model, activeAttempt])
-
-  const onTranslationToggle = useCallback(() => {
-    model.translation.toggle()
-    model.dropdown.setExpanded(true)
-  }, [model])
-
-  return {
-    display: {
-      text: displayText,
-      isLoading: isActiveTranscriptLoading || isTranslationLoading,
-    },
-    flags: {
-      playerState: playerState as PlayerState,
-      hasActiveAudio,
-      anyAttemptHasAudio,
-      canTranslate,
-      isTranslationActive,
-    },
-    actions: {
-      onPlayPress,
-      onTranslationToggle,
-    },
-  }
-}