@magmamath/students-features 0.3.0-rc.13 → 0.3.0-rc.14

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

@@ -1,23 +1,16 @@
+import { attach, createEffect, createEvent, EventCallable, restore, sample, Store } from 'effector'
 import {
-  createEvent,
-  restore,
-  attach,
-  createEffect,
-  type Effect,
-  sample,
-  Store,
-  EventCallable,
-} from 'effector'
-import {
-  TranslateAlternativesFxProps,
+  AddTranslationToAlternativesProps,
   TranslateBatchFxProps,
   TranslateMessageFxProps,
+  TranslateRequestProps,
 } from '../types/translation.types'
 import { ChatbotModelProps, ConversationMessage } from '../types/model.types'
 import { GetAlternativesResponse } from '../types/api.types'
 import { decodeHTMLEntities } from '../helpers'
 import { ChatbotAPI } from './api'
 import { EntityFieldStore } from '../../../lib/effector/createEntityFieldStore'
+import { addTranslationsToAlternative, getOptionsForTranslation } from './translation.helpers'
 
 type ChatbotTranslationProps = {
   api: ChatbotAPI
@@ -40,12 +33,7 @@ export class ChatbotTranslation {
   readonly setIsTranslated = createEvent<boolean>()
   readonly $isTranslated = restore(this.setIsTranslated, false)
 
-  readonly translateMessageFx: Effect<TranslateMessageFxProps, ConversationMessage>
-  readonly translateBatchFx: Effect<TranslateBatchFxProps['params'], ConversationMessage[]>
-  readonly translateAlternativesFx: Effect<
-    TranslateAlternativesFxProps['params'],
-    GetAlternativesResponse | null
-  >
+  readonly translateAllMessagesFx
 
   constructor({
     api,
@@ -60,10 +48,15 @@ export class ChatbotTranslation {
     this.messagesModel = messagesModel
     this.alternativesModel = alternativesModel
 
-    this.translateAlternativesFx = this.createTranslateAlternativesEffect()
-    this.translateMessageFx = this.createTranslateMessageEffect()
-    this.translateBatchFx = this.createTranslateBatchEffect()
-
+    this.translateAllMessagesFx = attach({
+      source: [this.$key, this.messagesModel.$state, this.alternativesModel.$store],
+      mapParams: (params: TranslateBatchFxProps['params'], [key, messages, alternatives]) => ({
+        params,
+        messages: messages[key] ?? [],
+        alternatives,
+      }),
+      effect: this.translateBatchFx,
+    })
     this.initTranslationSamples()
   }
 
@@ -73,7 +66,7 @@ export class ChatbotTranslation {
       return true
     }
 
-    const allTranslated = messages.every(message => message.translatedMessage)
+    const allTranslated = messages.every((message) => message.translatedMessage)
     if (allTranslated) {
       this.setIsTranslated(true)
       return true
@@ -84,69 +77,91 @@ export class ChatbotTranslation {
 
   private initTranslationSamples() {
     sample({
-      clock: this.translateBatchFx.doneData,
+      clock: this.translateAllMessagesFx.doneData,
       source: [this.$key] as const,
       fn: ([key], translatedMessages) => ({ key, data: translatedMessages }),
       target: this.messagesModel.setField,
     })
   }
 
-  private createTranslateAlternativesEffect() {
-    return attach({
-      source: [this.alternativesModel.$store],
-      mapParams: (params: TranslateAlternativesFxProps['params'], [alternatives]) => ({
-        params,
-        alternatives,
-      }),
-      effect: createEffect(async ({ alternatives, params }: TranslateAlternativesFxProps) => {
-        const hintAlternatives = alternatives?.options.hints ?? []
-        const defaultAlternatives = alternatives?.options.default ?? []
-
-        const translatedAlternatives = { ...alternatives }
-
-        if (hintAlternatives.length) {
-          const hintText = hintAlternatives.map(({ text }) => text)
-          const response = await this.api.translateTextFx({
-            text: hintText,
-            targetLanguage: params.targetLanguage,
-          })
-
-          if (translatedAlternatives.options) {
-            translatedAlternatives.options.hints = hintAlternatives.map((alternative, index) => ({
-              ...alternative,
-              translatedMessage: decodeHTMLEntities(
-                response.data.translations[index].translatedText,
-              ),
-            }))
-          }
-        }
+  private async translateRequest<List extends Record<string, string[]>>(
+    props: TranslateRequestProps<List>,
+  ) {
+    const text = Object.values(props.text).flat()
 
-        if (defaultAlternatives.length) {
-          const defaultText = defaultAlternatives.map(({ text }) => text)
-          const response = await this.api.translateTextFx({
-            text: defaultText,
-            targetLanguage: params.targetLanguage,
-          })
-
-          if (translatedAlternatives.options) {
-            translatedAlternatives.options.default = defaultAlternatives.map(
-              (alternative, index) => ({
-                ...alternative,
-                translatedText: decodeHTMLEntities(
-                  response.data.translations[index].translatedText,
-                ),
-              }),
-            )
-          }
-        }
+    const response = await this.api.translateTextFx({
+      text,
+      targetLanguage: props.targetLanguage,
+    })
 
-        return translatedAlternatives as GetAlternativesResponse | null
-      }),
+    const translatedText = response.data.translations.map(({ translatedText }) =>
+      decodeHTMLEntities(translatedText),
+    )
+
+    const result = {} as Record<keyof List, string[]>
+    Object.keys(props.text).forEach((key) => {
+      const count = props.text[key].length
+      result[key as keyof List] = translatedText.splice(0, count)
     })
+    return result
   }
 
-  private createTranslateMessageEffect() {
-    return createEffect(async ({ message, targetLanguage }: TranslateMessageFxProps) => {
+  private addTranslationToAlternatives(props: AddTranslationToAlternativesProps) {
+    this.alternativesModel.set(addTranslationsToAlternative(props))
+  }
+
+  private readonly translateBatchFx = createEffect(
+    async ({ messages, params, alternatives }: TranslateBatchFxProps) => {
+      if (this.shouldSkipTranslation(messages)) {
+        return messages
+      }
+
+      const defaultMessages = [this.defaultMessages.error, this.defaultMessages.endMessage]
+      const defaultOptions = [this.defaultMessages.anotherHintOption]
+      const options = getOptionsForTranslation({ lastMessage: messages.at(-1), alternatives })
+
+      const translatedTextsList = await this.translateRequest({
+        text: {
+          messages: messages.map(({ message }) => message),
+          defaultMessages: defaultMessages.map(({ message }) => message),
+          defaultOptions: defaultOptions.map(({ text }) => text),
+          lastMessage: options.lastMessage || [],
+          alternativesHints: options.alternatives?.hints || [],
+          alternativesDefaults: options.alternatives?.default || [],
+        },
+        targetLanguage: params.targetLanguage,
+      })
+
+      translatedTextsList.defaultMessages.forEach((message, index) => {
+        defaultMessages[index].translatedMessage = message
+      })
+      translatedTextsList.defaultOptions.forEach((message, index) => {
+        defaultOptions[index].translatedText = message
+      })
+      if (options.alternatives && alternatives) {
+        this.addTranslationToAlternatives({
+          alternatives,
+          translatedHints: translatedTextsList.alternativesHints,
+          translatedDefaults: translatedTextsList.alternativesDefaults,
+        })
+      }
+
+      // TODO: move this AFTER state update in sample and remove initTranslationSamples it is not needed
+      this.setIsTranslated(true)
+
+      return messages.map((message, index) => {
+        const isLastMessage = index === messages.length - 1
+        return {
+          ...message,
+          options: isLastMessage ? translatedTextsList.lastMessage : message.options,
+          translatedMessage: translatedTextsList.messages[index],
+        }
+      }) as ConversationMessage[]
+    },
+  )
+
+  public readonly translateMessageFx = createEffect(
+    async ({ message, targetLanguage }: TranslateMessageFxProps) => {
       const optionsText = message.options.map(({ text }) => text)
       const response = await this.api.translateTextFx({
         text: [message.message, ...optionsText],
@@ -165,79 +180,8 @@ export class ChatbotTranslation {
         translatedMessage: decodeHTMLEntities(response.data.translations[0].translatedText),
         options: newOptions,
       } as ConversationMessage
-    })
-  }
-
-  private createTranslateBatchEffect() {
-    return attach({
-      source: [this.$key, this.messagesModel.$state],
-      mapParams: (params: TranslateBatchFxProps['params'], [key, messages]) => ({
-        params,
-        messages: messages[key] ?? [],
-      }),
-      effect: createEffect(async ({ messages, params }: TranslateBatchFxProps) => {
-        if (this.shouldSkipTranslation(messages)) {
-          return messages
-        }
-
-        const messagesText = messages.map(({ message }) => message)
-        const response = await this.api.translateTextFx({
-          text: messagesText,
-          targetLanguage: params.targetLanguage,
-        })
-
-        const lastMessage = messages.at(-1)
-        const lastMessageTranslatedOptions = lastMessage
-          ? await this.translateMessageOptions(lastMessage, params.targetLanguage)
-          : undefined
-
-        const errorMessageTranslationResponse = await this.api.translateTextFx({
-          text: [this.defaultMessages.error.message],
-          targetLanguage: params.targetLanguage,
-        })
-
-        this.defaultMessages.error.translatedMessage = decodeHTMLEntities(
-          errorMessageTranslationResponse.data.translations[0].translatedText,
-        )
-
-        // TODO: move this AFTER state update in sample and remove initTranslationSamples it is not needed
-        // TODO: maybe just one request to translate everything
-        this.setIsTranslated(true)
-
-        const translatedMessages = response.data.translations.map(
-          ({ translatedText }) => translatedText,
-        )
-
-        return messages.map((message, index) => {
-          const isLastMessage = index === messages.length - 1
-          return {
-            ...message,
-            options: isLastMessage ? lastMessageTranslatedOptions : message.options,
-            translatedMessage: decodeHTMLEntities(translatedMessages[index]),
-          }
-        }) as ConversationMessage[]
-      }),
-    })
-  }
-
-  private async translateMessageOptions(message: ConversationMessage, targetLanguage: string) {
-    if (!message?.options?.length) {
-      const translatedAlternatives = await this.translateAlternativesFx({ targetLanguage })
-      this.alternativesModel.set(translatedAlternatives)
-      return
-    }
-
-    const optionsText = message.options.map(({ text }) => text)
-    const response = await this.api.translateTextFx({
-      text: optionsText,
-      targetLanguage,
-    })
-
-    return message.options.map((option, index) => ({
-      ...option,
-      translatedText: decodeHTMLEntities(response.data.translations[index].translatedText),
-    }))
-  }
+    },
+  )
 
   public reset() {
     this.setIsTranslated(false)

package/src/features/chatbot/types/model.types.ts

@@ -10,6 +10,7 @@ import {
   ChatAnswer,
   GetAlternativesPayload,
 } from './api.types'
+import { AccomplishTo } from '../../../lib/helpers/types'
 
 export type ConversationMessage = {
   id: string
@@ -32,6 +33,8 @@ export type ChatbotModelProps = {
   messages: {
     error: ConversationMessage
     start: ConversationMessage
+    endMessage: ConversationMessage
+    anotherHintOption: ChatAnswer
   }
 }
 
@@ -66,3 +69,5 @@ export type ChatbotRenderer = {
   variant: MessageVariant
   withTextToSpeech: boolean
 }
+
+export type CreateMessageResponse = AccomplishTo<PostMessageResponse, ConversationMessage>

package/src/features/chatbot/types/translation.types.ts

@@ -6,6 +6,7 @@ export type TranslateBatchFxProps = {
   params: {
     targetLanguage: string
   }
+  alternatives: GetAlternativesResponse | null
 }
 
 export type TranslateMessageFxProps = {
@@ -13,9 +14,24 @@ export type TranslateMessageFxProps = {
   targetLanguage: string
 }
 
-export type TranslateAlternativesFxProps = {
+export type AddTranslationToAlternativesProps = {
+  alternatives: GetAlternativesResponse
+  translatedHints: string[]
+  translatedDefaults: string[]
+}
+export type GetOptionsProps = {
   alternatives: GetAlternativesResponse | null
-  params: {
-    targetLanguage: string
-  }
+  lastMessage: ConversationMessage | undefined
+}
+export type GetOptionsResult = {
+  lastMessage: string[] | null
+  alternatives: {
+    hints: string[]
+    default: string[]
+  } | null
+}
+
+export type TranslateRequestProps<List extends Record<string, string[]>> = {
+  text: List
+  targetLanguage: string
 }

package/src/index.ts

@@ -1,4 +1,5 @@
 export { useFeaturesLocalization, setFeaturesLocalization, Locale } from './shared/translation'
 export type { LocalizationConfig } from './shared/translation'
+export { generateRandomId } from './lib/helpers/helpers'
 export * from './features/chatbot'
 export * from './features/feedback'

package/src/lib/helpers/types.ts

@@ -0,0 +1 @@
+export type AccomplishTo<T, To> = Partial<Omit<To, keyof T>> & T