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

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

@@ -0,0 +1,174 @@
+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

@@ -0,0 +1,171 @@
+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

@@ -0,0 +1,148 @@
+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

@@ -0,0 +1,87 @@
+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

@@ -0,0 +1,50 @@
+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),
+    )
+  }
+}