@magmamath/students-features 1.6.4 → 1.7.0-rc.0

package/src/features/translation/model/TranslationModel.ts

@@ -1,174 +0,0 @@
-import {
-  attach,
-  combine,
-  createEffect,
-  createEvent,
-  restore,
-  sample,
-  split,
-  Store,
-  Unit,
-} from 'effector'
-import { GoogleTranslationProvider } from '../providers/google/GoogleTranslationProvider'
-import {
-  GoogleTranslateProps,
-  GoogleTranslateResponse,
-} from '../providers/google.types'
-import { TranslationService } from './TranslationService'
-import {
-  preservedWordsReplacers,
-  wordsToPreserve,
-} from '../preserve/wordsToPreserve'
-import {
-  CHOICES_CACHE_KEY_SUFFIX,
-  DESCRIPTION_CACHE_KEY_SUFFIX,
-  GBD_TEXT_CACHE_SUFFIX,
-} from '../constants'
-import {
-  TranslatableProblem,
-  TranslateAllFxParams,
-  TranslateFxParams,
-} from '../types'
-
-type TranslationModelProps<TProblem extends TranslatableProblem> = {
-  $problem: Store<TProblem | null>
-  $problemId: Store<string>
-  $assignmentId: Store<string>
-  $currentProblemIndex: Store<number>
-  $translationLanguageCode: Store<string>
-  $contentLanguageCode?: Store<string>
-  $isTranslationLocked: Store<boolean>
-  languageChanged: Unit<unknown>
-  api: {
-    translateRequest: (payload: GoogleTranslateProps) => Promise<GoogleTranslateResponse>
-  }
-  getGreatWorkFeedbackText?: () => string
-}
-
-export class TranslationModel<TProblem extends TranslatableProblem = TranslatableProblem> {
-  private readonly service: TranslationService
-
-  public readonly toggle = createEvent()
-  public readonly setTranslated = createEvent<boolean>()
-  public readonly reset = createEvent()
-
-  public readonly $isTranslationActive = restore(this.setTranslated, false).reset(this.reset)
-  public readonly $isTranslated = this.$isTranslationActive
-  public readonly $isTranslationPending
-
-  public readonly translateFx
-  public readonly translateAllFx
-
-  constructor({
-    $problem,
-    $problemId,
-    $assignmentId,
-    $currentProblemIndex,
-    $translationLanguageCode,
-    $contentLanguageCode,
-    $isTranslationLocked,
-    languageChanged,
-    api,
-    getGreatWorkFeedbackText,
-  }: TranslationModelProps<TProblem>) {
-    this.service = new TranslationService({
-      preserve: {
-        map: wordsToPreserve,
-        replacers: preservedWordsReplacers,
-      },
-      providers: [new GoogleTranslationProvider({ api })],
-      onError: () => this.reset(),
-    })
-
-    this.service.bindCustomCacheKey(
-      $problemId,
-      (problemId, { target }) => `${problemId}::${target}`,
-    )
-    this.service.bindTargetLanguage($translationLanguageCode)
-    if ($contentLanguageCode) {
-      this.service.bindSourceLanguage($contentLanguageCode)
-    }
-
-    this.translateAllFx = attach({
-      source: {
-        problem: $problem,
-        translationLanguageCode: $translationLanguageCode,
-      },
-      mapParams: (_: void, source) => source,
-      effect: createEffect(({ problem, translationLanguageCode }: TranslateAllFxParams<TProblem>) => {
-        if (!problem) return
-
-        const promises: Promise<unknown>[] = [
-          this.service.translate(problem.richDescription || problem.description, {
-            cacheKeySuffix: DESCRIPTION_CACHE_KEY_SUFFIX,
-          }),
-          this.service.translate(problem.answerVariants, {
-            cacheKeySuffix: CHOICES_CACHE_KEY_SUFFIX,
-          }),
-        ]
-
-        if (getGreatWorkFeedbackText) {
-          promises.push(
-            this.service.translate(getGreatWorkFeedbackText(), {
-              cacheKey: `${translationLanguageCode}${GBD_TEXT_CACHE_SUFFIX}`,
-            }),
-          )
-        }
-
-        return Promise.all(promises)
-      }),
-    })
-
-    this.translateFx = createEffect(({ cacheKey, text }: TranslateFxParams) => {
-      return this.service.translate(text, { cacheKey })
-    })
-
-    this.$isTranslationActive.on(this.translateAllFx.doneData, () => true)
-    this.$isTranslationActive.on(this.translateAllFx.fail, () => false)
-
-    split({
-      source: sample({
-        clock: this.toggle,
-        source: this.$isTranslationActive,
-      }),
-      match: {
-        on: (isTranslated) => !isTranslated,
-        off: (isTranslated) => isTranslated,
-      },
-      cases: {
-        on: this.translateAllFx,
-        off: this.reset,
-      },
-    })
-
-    sample({
-      clock: languageChanged,
-      fn: () => false,
-      target: this.setTranslated,
-    })
-
-    sample({
-      clock: [$currentProblemIndex, $assignmentId, this.$isTranslationActive],
-      source: {
-        isTranslated: this.$isTranslationActive,
-        isLocked: $isTranslationLocked,
-      },
-      filter: ({ isTranslated, isLocked }) => isLocked || isTranslated,
-      target: this.translateAllFx,
-    })
-
-    this.$isTranslationPending = combine(
-      this.translateAllFx.pending,
-      this.translateFx.pending,
-      (isAllPending, isOnePending) => isAllPending || isOnePending,
-    )
-  }
-
-  public getTranslated<T extends string | string[]>(key: string): T | undefined {
-    return this.service.getCached<T>(key)
-  }
-
-  public clearCache() {
-    this.service.reset()
-  }
-}

package/src/features/translation/model/TranslationPreprocessor.ts

@@ -1,171 +0,0 @@
-import { LanguageGlossary } from '../providers/translation.interface'
-import { maskSegment, replaceMappedTokens } from '../helpers'
-import { Replacement } from '../types'
-
-const KATEX_REGEX = /\$(.+?)\$/g
-const NEWLINE_REGEX = /\n/g
-const QUOTE_REGEX = /\\(['"])/g
-const DOLLAR_REGEX = /\\\$/gm
-const COMMA_REGEX = /,/gm
-const DOT_REGEX = /\./gm
-
-const wrapNoTranslate = (content: string) => `<span translate="no">${content}</span>`
-
-const KATEX_PLACEHOLDER = wrapNoTranslate('{{@}}')
-const NEWLINE__PLACEHOLDER = wrapNoTranslate('{{#}}')
-const QUOTE_PLACEHOLDER = wrapNoTranslate('{{""}}')
-const DOLLAR_PLACEHOLDER = wrapNoTranslate('{{!}}')
-const COMMA_PLACEHOLDER = wrapNoTranslate('{{,}}')
-const DOT_PLACEHOLDER = wrapNoTranslate('{{.}}')
-
-const defaultOrderedReplacersMap = [
-  [DOLLAR_REGEX, DOLLAR_PLACEHOLDER],
-  [KATEX_REGEX, KATEX_PLACEHOLDER],
-  [NEWLINE_REGEX, NEWLINE__PLACEHOLDER],
-  [QUOTE_REGEX, QUOTE_PLACEHOLDER],
-  [COMMA_REGEX, COMMA_PLACEHOLDER],
-  [DOT_REGEX, DOT_PLACEHOLDER],
-] as const
-
-type SetupPreservableProps = {
-  glossaryToPreserve: LanguageGlossary
-  preserveWordsReplacers: [RegExp, string][]
-}
-
-export class TranslationKatexPreprocessor {
-  private static plaintextConverter: (text: string) => string = (text) => text
-
-  public static setPlaintextConverter(converter: (text: string) => string) {
-    this.plaintextConverter = converter
-  }
-
-  public static shouldSkipTranslation(text: string | string[] = '') {
-    if (Array.isArray(text)) {
-      return text.every(
-        (t) => this.isMathExpressionOnly(t) || this.isSingleLetter(t) || this.isMathSymbolsOnly(t),
-      )
-    }
-
-    return (
-      this.isMathExpressionOnly(text) || this.isSingleLetter(text) || this.isMathSymbolsOnly(text)
-    )
-  }
-
-  public static isMathExpressionOnly(text: string) {
-    return /^[\d\s+\-*/^=().\\><%!|]+$/.test(text.trim())
-  }
-
-  public static isSingleLetter(text: string) {
-    return /^[a-zA-Z]$/.test(text)
-  }
-
-  public static isMathSymbolsOnly(text: string) {
-    const plainText = this.plaintextConverter(text)
-    const cleanedUp = plainText.replace(/(\\\\|\\|\$|\−|\+|\=|\*|kr|pln|€|£|x|y|\{|\}|\÷)/gi, '')
-    const mathOnlyRegex = /^(?=.*\d)[0-9+\-×÷*/^().\s]+$/u
-    return cleanedUp.length > 0 && mathOnlyRegex.test(cleanedUp)
-  }
-
-  private globalTargetLanguage: string | null = null
-  private preserveWordsMap: LanguageGlossary = {}
-  private preserveWordsReplacers: [RegExp, string][] = []
-
-  private normalizePlaceholderSpacing(text: string) {
-    return text
-      .replace(/\s+(<span[^>]*translate="no"[^>]*>)/g, '$1')
-      .replace(/(<\/span>)\s+/g, '$1')
-  }
-
-  public sanitize(text: string): { sanitized: string; replacements: Replacement[] } {
-    const language = this.globalTargetLanguage ?? ''
-    const replacements: Replacement[] = []
-    let sanitizedText = text
-
-    defaultOrderedReplacersMap.forEach(([regex, placeholder]) => {
-      sanitizedText = maskSegment({
-        text: sanitizedText,
-        regex,
-        placeholder,
-        replacements,
-      })
-    })
-
-    this.preserveWordsReplacers.forEach(([regex, placeholder]) => {
-      const preserveWordsMapTarget = this.preserveWordsMap[language]
-
-      sanitizedText = maskSegment({
-        text: sanitizedText,
-        regex,
-        placeholder,
-        replacements,
-        shouldSkip: (match) =>
-          this.skipCustomReplacerSanitizeWithoutGlossary(match, preserveWordsMapTarget),
-      })
-    })
-
-    return { sanitized: sanitizedText, replacements }
-  }
-
-  public restore(text: string, replacements: Replacement[]) {
-    let restored = this.normalizePlaceholderSpacing(text)
-    replacements.forEach(({ placeholder, original, leftPad, rightPad }) => {
-      const wrapped = `${leftPad ? ' ' : ''}${original}${rightPad ? ' ' : ''}`
-      restored = restored.replace(placeholder, wrapped)
-    })
-
-    return this.applyPreserved(restored)
-  }
-
-  public sanitizeBatch(texts: string[]): { sanitized: string[]; replacements: Replacement[][] } {
-    const sanitized: string[] = []
-    const replacements: Replacement[][] = []
-
-    texts.forEach((t) => {
-      const { sanitized: s, replacements: r } = this.sanitize(t)
-      sanitized.push(s)
-      replacements.push(r)
-    })
-
-    return { sanitized, replacements }
-  }
-
-  public restoreBatch(texts: string[], replacementsArray: Replacement[][]) {
-    return texts.map((t, i) => {
-      const restored = this.restore(t, replacementsArray[i])
-      return this.applyPreserved(restored)
-    })
-  }
-
-  // Glossaries apply after translation response and do not remove words from payload.
-  // This replaces words from the string before sending request to API to completely avoid
-  // translating it. We use it to avoid "context localization" e.g. Google API changes numbers
-  // when units are passed and target language is from a different region. We must preserve
-  // words like "miles" and the exact number in this case.
-  public setupPreservable({ glossaryToPreserve, preserveWordsReplacers }: SetupPreservableProps) {
-    this.preserveWordsMap = glossaryToPreserve
-    this.preserveWordsReplacers = preserveWordsReplacers
-  }
-
-  public setupTarget(language: string) {
-    this.globalTargetLanguage = language
-  }
-
-  private skipCustomReplacerSanitizeWithoutGlossary(
-    match: string,
-    preserveWordsMapTarget?: Record<string, string>,
-  ) {
-    if (!preserveWordsMapTarget) return true
-
-    const normalized = match.toLowerCase()
-    const glossaryKeys = Object.keys(preserveWordsMapTarget).map((key) => key.toLowerCase())
-
-    return !glossaryKeys.includes(normalized)
-  }
-
-  private applyPreserved(restored: string) {
-    const language = this.globalTargetLanguage ?? ''
-    const preservedMap = this.preserveWordsMap[language]
-
-    return preservedMap ? replaceMappedTokens(restored, preservedMap) : restored
-  }
-}

package/src/features/translation/model/TranslationService.ts

@@ -1,148 +0,0 @@
-import { Store } from 'effector'
-import { TranslationKatexPreprocessor } from './TranslationPreprocessor'
-import { LanguageGlossary, TranslationProvider } from '../providers/translation.interface'
-
-type TranslationServiceProps = {
-  providers: TranslationProvider[]
-  preserve?: {
-    map: LanguageGlossary
-    replacers: [RegExp, string][]
-  }
-  onError?: () => void
-}
-
-export type TranslateConfigProps = {
-  targetLang?: string
-  sourceLang?: string
-  cacheKeySuffix?: string
-  cacheKey?: string
-}
-
-export class TranslationService {
-  private readonly preprocessor = new TranslationKatexPreprocessor()
-  private readonly cache = new Map<string, string | string[]>()
-  private readonly providers: TranslationProvider[] = []
-  private readonly onError
-
-  private globalTargetLanguage: string | null = null
-  private sourceLanguage: string | null = null
-  private customCacheKeyFn: ((text: string | string[], target: string) => string) | null = null
-
-  constructor({ providers, preserve, onError }: TranslationServiceProps) {
-    this.providers = providers
-    this.onError = onError
-
-    if (preserve) {
-      this.preprocessor.setupPreservable({
-        glossaryToPreserve: preserve.map,
-        preserveWordsReplacers: preserve.replacers,
-      })
-    }
-  }
-
-  private getTargetLanguage(targetLang?: string) {
-    const target = targetLang || this.globalTargetLanguage
-    if (!target) {
-      throw new Error(
-        'Target language is missing, either provide in arguments or use .bindTargetLanguage()',
-      )
-    }
-    return target
-  }
-
-  private getProvider(target: string) {
-    const provider = this.providers.find((svc) => svc.isTargetSupported(target))
-    if (!provider) throw new Error(`This target language: "${target}" is not supported.`)
-    return provider
-  }
-
-  private createCacheKey(text: string | string[], target: string, suffix?: string) {
-    let baseKey: string
-
-    if (this.customCacheKeyFn) {
-      baseKey = this.customCacheKeyFn(text, target)
-    } else {
-      baseKey = Array.isArray(text) ? `${JSON.stringify(text)}::${target}` : `${text}::${target}`
-    }
-
-    return suffix ? `${baseKey}${suffix}` : baseKey
-  }
-
-  public translate = async <T extends string | string[]>(
-    text: T = '' as T,
-    config?: TranslateConfigProps,
-  ): Promise<T> => {
-    const isArrayInput = Array.isArray(text)
-    const target = this.getTargetLanguage(config?.targetLang) ?? ''
-
-    if (!text.length || TranslationKatexPreprocessor.shouldSkipTranslation(text)) {
-      const key = config?.cacheKey ?? this.createCacheKey(text, target, config?.cacheKeySuffix)
-      if (this.cache.has(key)) return this.cache.get(key) as T
-
-      return text
-    }
-
-    const source = config?.sourceLang ?? this.sourceLanguage ?? undefined
-    const provider = this.getProvider(target)
-    const key = config?.cacheKey ?? this.createCacheKey(text, target, config?.cacheKeySuffix)
-
-    if (this.cache.has(key)) return this.cache.get(key) as T
-
-    let translated: string | string[]
-
-    if (isArrayInput) {
-      const { sanitized, replacements } = this.preprocessor.sanitizeBatch(text)
-      const response = await provider.requestBatch(sanitized, target, source)
-      translated = this.preprocessor.restoreBatch(response, replacements)
-    } else {
-      const { sanitized, replacements } = this.preprocessor.sanitize(text)
-      const response = await provider.request(sanitized, target, source)
-      translated = this.preprocessor.restore(response, replacements)
-    }
-
-    this.cache.set(key, translated)
-
-    return translated as T
-  }
-
-  public bindTargetLanguage<T extends string>(
-    store: Store<T>,
-    callback?: (value: T) => string,
-  ): this {
-    store.watch((t) => {
-      const value = callback ? callback(t) : t
-      this.globalTargetLanguage = value
-      this.preprocessor.setupTarget(value)
-    })
-
-    return this
-  }
-
-  public bindSourceLanguage<T extends string>(store: Store<T>): this {
-    store.watch((value) => {
-      this.sourceLanguage = value
-    })
-
-    return this
-  }
-
-  public bindCustomCacheKey<T extends string>(
-    store: Store<T>,
-    callback: (value: T, input: { text: string | string[]; target: string }) => string,
-  ): this {
-    store.watch((t) => {
-      this.customCacheKeyFn = (text: string | string[], target: string) =>
-        callback(t, { text, target })
-    })
-
-    return this
-  }
-
-  public getCached<T extends string | string[]>(key: string): T | undefined {
-    return this.cache.get(key) as T | undefined
-  }
-
-  public reset() {
-    this.cache.clear()
-  }
-}

package/src/features/translation/preserve/wordsToPreserve.ts

@@ -1,87 +0,0 @@
-export const wordsToPreserve: Record<string, Record<string, string>> = {
-  es: { mile: 'milla', miles: 'millas' },
-  hy: { mile: 'մղոն', miles: 'մղոններ' },
-  fr: { mile: 'mille', miles: 'milles' },
-  ru: { mile: 'миля', miles: 'мили' },
-  ar: { mile: 'ميل', miles: 'أميال' },
-  is: { mile: 'míla', miles: 'mílur' },
-  ja: { mile: 'マイル', miles: 'マイル' },
-  'zh-Hans': { mile: '英里', miles: '英里' },
-  af: { mile: 'myl', miles: 'myls' },
-  ko: { mile: '마일', miles: '마일' },
-  de: { mile: 'Meile', miles: 'Meilen' },
-  zu: { mile: 'ileyili', miles: 'amayela' },
-  'zh-Hant': { mile: '英里', miles: '英里' },
-  it: { mile: 'miglio', miles: 'miglia' },
-  ht: { mile: 'miy', miles: 'miy' },
-  hi: { mile: 'मील', miles: 'मील' },
-  pt: { mile: 'milha', miles: 'milhas' },
-  sq: { mile: 'milje', miles: 'milje' },
-  el: { mile: 'μίλι', miles: 'μίλια' },
-  pl: { mile: 'mila', miles: 'mile' },
-  te: { mile: 'మైలు', miles: 'మైలు‌లు' },
-  am: { mile: 'ማይል', miles: 'ማይሎች' },
-  ta: { mile: 'மைல்', miles: 'மைல்கள்' },
-  vi: { mile: 'dặm', miles: 'dặm' },
-  uk: { mile: 'миля', miles: 'милі' },
-  haw: { mile: 'maila', miles: 'maila' },
-  sv: { mile: 'mile', miles: 'miles' },
-  bn: { mile: 'মাইল', miles: 'মাইল' },
-  tl: { mile: 'milya', miles: 'milya' },
-  ga: { mile: 'míle', miles: 'míleanna' },
-  nl: { mile: 'mijl', miles: 'mijlen' },
-  ur: { mile: 'میل', miles: 'میل' },
-  ee: { mile: 'maili', miles: 'maili' },
-  en: { mile: 'mile', miles: 'miles' },
-  az: { mile: 'mil', miles: 'mil' },
-  gu: { mile: 'માઈલ', miles: 'માઈલ્સ' },
-  ml: { mile: 'മൈൽ', miles: 'മൈലുകൾ' },
-  pa: { mile: 'ਮਾਈਲ', miles: 'ਮਾਈਲਾਂ' },
-  as: { mile: 'মাইল', miles: 'মাইল' },
-  bm: { mile: 'maili', miles: 'maili' },
-  he: { mile: 'מייל', miles: 'מיילים' },
-  fa: { mile: 'مایل', miles: 'مایل‌ها' },
-  fi: { mile: 'maili', miles: 'mailia' },
-  tr: { mile: 'mil', miles: 'mil' },
-  da: { mile: 'mil', miles: 'mil' },
-  bg: { mile: 'миля', miles: 'мили' },
-  xh: { mile: 'imayile', miles: 'iimayile' },
-  yi: { mile: 'מייל', miles: 'מיילן' },
-  ps: { mile: 'مایل', miles: 'مایلونه' },
-  mr: { mile: 'मैल', miles: 'मैले' },
-  eu: { mile: 'mila', miles: 'milak' },
-  bs: { mile: 'milja', miles: 'milje' },
-  cs: { mile: 'míle', miles: 'míle' },
-  yo: { mile: 'maili', miles: 'maili' },
-  ak: { mile: 'maili', miles: 'maili' },
-  ro: { mile: 'milă', miles: 'mile' },
-  mn: { mile: 'миль', miles: 'миль' },
-  bho: { mile: 'माइल', miles: 'माइल्स' },
-  ka: { mile: 'მილი', miles: 'მილი' },
-  ca: { mile: 'milla', miles: 'milles' },
-  be: { mile: 'міля', miles: 'мілі' },
-  sw: { mile: 'maili', miles: 'maili' },
-  eo: { mile: 'mejlo', miles: 'mejloj' },
-  th: { mile: 'ไมล์', miles: 'ไมล์' },
-  ay: { mile: 'maili', miles: 'maili' },
-  doi: { mile: 'माइल', miles: 'माइल्स' },
-  hr: { mile: 'milja', miles: 'milje' },
-  sm: { mile: 'maila', miles: 'maila' },
-  kn: { mile: 'ಮೈಲು', miles: 'ಮೈಲುಗಳು' },
-  et: { mile: 'miil', miles: 'miilid' },
-  ceb: { mile: 'milya', miles: 'milya' },
-  ig: { mile: 'maịlụ', miles: 'maịlụ' },
-  ne: { mile: 'माइल', miles: 'माइलहरू' },
-  uz: { mile: 'mil', miles: 'mil' },
-  cy: { mile: 'filltir', miles: 'mili' },
-}
-
-const MILE_REGEX = /mile/gm
-const MILE_PLACEHOLDER = '__!{21_37_70}!__'
-const MILES_REGEX = /miles/gm
-const MILES_PLACEHOLDER = '__!{21_37_69}!__'
-
-export const preservedWordsReplacers: [RegExp, string][] = [
-  [MILES_REGEX, MILES_PLACEHOLDER],
-  [MILE_REGEX, MILE_PLACEHOLDER],
-]

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

@@ -1,50 +0,0 @@
-import { createEffect, Effect } from 'effector'
-import { LanguageGlossary, TranslationProvider } from '../translation.interface'
-import { GoogleTranslateLanguage, resolveGoogleLanguageCode } from './supportedLanguages'
-import { GoogleTranslateProps, GoogleTranslateResponse } from '../google.types'
-import { decodeHtmlEntities } from '../../helpers'
-
-type GoogleTranslationProviderProps = {
-  api: {
-    translateRequest: (payload: GoogleTranslateProps) => Promise<GoogleTranslateResponse>
-  }
-  glossaries?: LanguageGlossary
-}
-
-export class GoogleTranslationProvider extends TranslationProvider {
-  private readonly getTranslationFx: Effect<GoogleTranslateProps, GoogleTranslateResponse>
-
-  constructor({ api, glossaries }: GoogleTranslationProviderProps) {
-    super({ supportedLanguages: Object.values(GoogleTranslateLanguage), glossaries })
-    this.getTranslationFx = createEffect(api.translateRequest)
-  }
-
-  public resolveLanguage(language: string): string | null {
-    return resolveGoogleLanguageCode(language)
-  }
-
-  public async request(text: string, targetLanguage: string, sourceLanguage?: string) {
-    const resolvedTarget = this.resolveLanguage(targetLanguage) ?? targetLanguage
-    const resolvedSource = sourceLanguage ? this.resolveLanguage(sourceLanguage) ?? undefined : undefined
-    const response = await this.getTranslationFx({
-      text: [text],
-      targetLanguage: resolvedTarget,
-      sourceLanguage: resolvedSource,
-    })
-    const translated = response.data.translations[0]?.translatedText ?? ''
-    return this.applyGlossary(decodeHtmlEntities(translated), resolvedTarget)
-  }
-
-  public async requestBatch(text: string[], targetLanguage: string, sourceLanguage?: string) {
-    const resolvedTarget = this.resolveLanguage(targetLanguage) ?? targetLanguage
-    const resolvedSource = sourceLanguage ? this.resolveLanguage(sourceLanguage) ?? undefined : undefined
-    const response = await this.getTranslationFx({
-      text,
-      targetLanguage: resolvedTarget,
-      sourceLanguage: resolvedSource,
-    })
-    return response.data.translations.map(({ translatedText }) =>
-      this.applyGlossary(decodeHtmlEntities(translatedText), resolvedTarget),
-    )
-  }
-}