@magmamath/students-features 1.3.22 → 1.3.23-rc.10

package/src/features/voice/playing/components/VoiceTranscriptionsDropdown.tsx

@@ -1,296 +0,0 @@
-import {
-  Typography,
-  ScrollableList,
-  CaretDownIcon,
-  COLORS,
-  IS_WEB,
-  ScrollableListScrollView,
-} from '@magmamath/react-native-ui'
-import { useUnit } from 'effector-react'
-import React, { useRef, useEffect, useState, useCallback, useMemo } from 'react'
-import {
-  TouchableOpacity,
-  StyleProp,
-  ViewStyle,
-  FlatList,
-  LayoutChangeEvent,
-  ScrollView,
-  View,
-  StyleSheet,
-} from 'react-native'
-import Animated, { FadeIn, FadeOut } from 'react-native-reanimated'
-import { AnswerAudio, VoiceTranscriptionItem } from '../../types'
-import { useVoiceTranscriptionsDropdown } from '../hooks/useVoiceTranscriptionsDropdown'
-import { VoicePlayerModel, PlayerState } from '../model'
-import { VoiceTranscriptionsDropdownItem } from './VoiceTranscriptionsDropdownItem'
-import { DROPDOWN_MAX_CONTENT_HEIGHT, NO_AUDIO_BE_MESSAGE } from '../../constants'
-import { useText } from '../../../../i18n/i18n'
-import { PlayButton } from '../../../../shared/components/PlayButton'
-import { getActiveAttempt, getAudioStatus } from '../../helpers'
-
-const AnimatedTouchableOpacity = Animated.createAnimatedComponent(TouchableOpacity)
-
-type VoiceTranscriptionsDropdownProps = {
-  style?: StyleProp<ViewStyle>
-  model: VoicePlayerModel
-  answers: AnswerAudio[]
-  attemptOffset: number
-  onAttemptOffsetChange: (offset: number) => void
-  attemptsCount: number
-  problemId: string
-}
-
-export const VoiceTranscriptionsDropdown = ({
-  style,
-  model,
-  answers,
-  attemptOffset,
-  onAttemptOffsetChange,
-  attemptsCount,
-  problemId,
-}: VoiceTranscriptionsDropdownProps) => {
-  const [attempts, setAttempts] = useState<VoiceTranscriptionItem[]>([])
-
-  const scrollRef = useRef<FlatList | null>(null)
-  const scrollViewRef = useRef<ScrollView | null>(null)
-  const itemLayoutsRef = useRef<Map<string, number>>(new Map())
-  const answersRef = useRef(answers)
-  answersRef.current = answers
-
-  const t = useText()
-
-  const [currentAttempt, transcriptsLoaded, playerState, isDropdownExpanded] = useUnit([
-    model.$currentAttempt,
-    model.loader.$transcriptsLoaded,
-    model.$playerState,
-    model.dropdown.$isExpanded,
-  ])
-
-  const activeAttempt = getActiveAttempt(attemptOffset, attemptsCount)
-
-  const answersKey = useMemo(
-    () => answers.map((a) => `${a._id}:${a.audioFileId ?? ''}`).join(','),
-    [answers],
-  )
-
-  const hasActiveTranscript =
-    activeAttempt !== null && answers?.[activeAttempt - 1]?.audioFileId !== undefined
-
-  const playButtonState = {
-    isActive: playerState !== PlayerState.IDLE,
-    isLoading: playerState === PlayerState.LOADING,
-    status: getAudioStatus(playerState),
-  }
-
-  const { listAnimatedStyle, iconAnimatedStyle, onListLayout } = useVoiceTranscriptionsDropdown(
-    model.dropdown,
-  )
-
-  const handleItemLayout = useCallback((id: string, event: LayoutChangeEvent) => {
-    itemLayoutsRef.current.set(id, event.nativeEvent.layout.y)
-  }, [])
-
-  const scrollToAttempt = useCallback(
-    (attemptNumber: number) => {
-      if (IS_WEB) {
-        const item = attempts.find((item) => item.attemptNumber === attemptNumber)
-        if (item) {
-          const y = itemLayoutsRef.current.get(item._id)
-          if (y !== undefined) {
-            scrollViewRef.current?.scrollTo({ y, animated: true })
-          }
-        }
-        return
-      }
-
-      const index = attempts.findIndex((item) => item.attemptNumber === attemptNumber)
-      if (index !== -1) {
-        scrollRef.current?.scrollToIndex({ index, animated: true, viewPosition: 0 })
-      }
-    },
-    [attempts],
-  )
-
-  const handleItemToggle = useCallback(
-    (attempt: number) => {
-      if (onAttemptOffsetChange && attemptsCount !== undefined) {
-        onAttemptOffsetChange(attemptsCount - attempt)
-      }
-    },
-    [onAttemptOffsetChange, attemptsCount],
-  )
-
-  const handlePlayPress = useCallback(() => {
-    if (activeAttempt) {
-      model.togglePlayPause(activeAttempt)
-    }
-  }, [model, activeAttempt])
-
-  const handleScrollToIndexFailed = useCallback((info: { index: number }) => {
-    setTimeout(() => {
-      scrollRef.current?.scrollToIndex({ index: info.index, animated: true, viewPosition: 0 })
-    }, 100)
-  }, [])
-
-  useEffect(() => {
-    model.reinitializePlayer()
-    return () => model.cleanup()
-  }, [model])
-
-  useEffect(() => {
-    const isLastAttemptsWithoutDrowing = !answers[answers.length - 1].drawing
-    if (answers.length > 0 && isLastAttemptsWithoutDrowing) {
-      model.dropdown.setExpanded(true)
-    } else {
-      model.dropdown.setExpanded(false)
-    }
-
-    model.resetPlayer()
-  }, [problemId])
-
-  useEffect(() => {
-    if (answersRef.current.some((answer) => answer.audioFileId)) {
-      model.initializeWithAudios(answersRef.current)
-      model.loader.loadAllTranscripts()
-    }
-  }, [model, answersKey])
-
-  useEffect(() => {
-    model.stopAudio()
-  }, [activeAttempt])
-
-  useEffect(() => {
-    const allAttempts = model.getAllAttempts()
-    setAttempts(allAttempts)
-  }, [answersKey, transcriptsLoaded, currentAttempt, model])
-
-  useEffect(() => {
-    if (isDropdownExpanded && activeAttempt !== null) {
-      setTimeout(() => {
-        scrollToAttempt(activeAttempt)
-      }, 500)
-    }
-  }, [isDropdownExpanded, answersKey])
-
-  const renderItem = useCallback(
-    ({ item }: { item: VoiceTranscriptionItem }) => {
-      const isLoading = model.loader.isTranscriptLoading(item.attemptNumber)
-      const transcript = model.loader.getTranscript(item.attemptNumber)
-      const isActive = activeAttempt === item.attemptNumber
-
-      return (
-        <VoiceTranscriptionsDropdownItem
-          isLoading={isActive && isLoading}
-          attempt={item.attemptNumber}
-          content={
-            transcript && transcript !== NO_AUDIO_BE_MESSAGE
-              ? transcript
-              : t('voice.transcriptNotAvailable')
-          }
-          isActive={isActive}
-          onToggle={handleItemToggle}
-          scrollToAttempt={scrollToAttempt}
-        />
-      )
-    },
-    [model, activeAttempt, t, handleItemToggle, scrollToAttempt],
-  )
-
-  return (
-    <Animated.View style={[styles.container, style]}>
-      <View style={styles.header}>
-        <Typography style={styles.title} variant="h7">
-          {t('voice.transcriptions')}
-        </Typography>
-        {hasActiveTranscript && (
-          <Animated.View entering={FadeIn.duration(120)} exiting={FadeOut.duration(120)}>
-            <PlayButton
-              state={playButtonState}
-              onPress={handlePlayPress}
-              activityIndicatorColor={COLORS.NEUTRAL_1}
-            />
-          </Animated.View>
-        )}
-      </View>
-
-      <Animated.View style={[listAnimatedStyle, { overflow: 'hidden' }]}>
-        <View onLayout={onListLayout} style={styles.listContainer}>
-          {IS_WEB ? (
-            <ScrollableListScrollView
-              bounces={false}
-              ref={scrollViewRef}
-              hideShadow
-              style={styles.list}
-              contentContainerStyle={styles.listContent}
-            >
-              {attempts.map((item) => (
-                <View key={item._id} onLayout={(e) => handleItemLayout(item._id, e)}>
-                  {renderItem({ item })}
-                </View>
-              ))}
-            </ScrollableListScrollView>
-          ) : (
-            <ScrollableList
-              bounces={false}
-              ref={scrollRef}
-              hideShadow
-              data={attempts}
-              keyExtractor={(item) => item._id}
-              onScrollToIndexFailed={handleScrollToIndexFailed}
-              renderItem={renderItem}
-              contentContainerStyle={styles.listContent}
-            />
-          )}
-        </View>
-      </Animated.View>
-
-      <AnimatedTouchableOpacity
-        style={[styles.expandButton, iconAnimatedStyle]}
-        onPress={() => model.dropdown.toggleExpand()}
-      >
-        <CaretDownIcon size={22} />
-      </AnimatedTouchableOpacity>
-    </Animated.View>
-  )
-}
-
-const styles = StyleSheet.create({
-  container: {
-    position: 'absolute',
-    top: 56,
-    left: 8,
-    width: 222,
-    maxHeight: 405,
-    minHeight: 51,
-    padding: 4,
-    boxShadow: '0px 1px 3px 0px rgba(51, 51, 51, 0.25)',
-    borderRadius: 12,
-    backgroundColor: COLORS.NEUTRAL_1,
-    overflow: 'hidden',
-  },
-  header: {
-    flexDirection: 'row',
-    justifyContent: 'space-between',
-    alignItems: 'center',
-    padding: 4,
-    marginBottom: 4,
-    height: 32,
-  },
-  title: {
-    color: COLORS.NEUTRAL_9,
-    marginLeft: 4,
-  },
-  list: { flex: 1 },
-  expandButton: {
-    justifyContent: 'center',
-    alignItems: 'center',
-  },
-  listContainer: {
-    position: 'absolute',
-    maxHeight: DROPDOWN_MAX_CONTENT_HEIGHT,
-    width: '100%',
-  },
-  listContent: {
-    paddingHorizontal: 4,
-  },
-})

package/src/features/voice/playing/components/VoiceTranscriptionsDropdownItem.tsx

@@ -1,128 +0,0 @@
-import { Pressable, StyleSheet, View } from 'react-native'
-import React, { memo, useCallback, useRef } from 'react'
-import {
-  Button,
-  ButtonSize,
-  ButtonVariant,
-  COLORS,
-  Loader,
-  LoaderColor,
-  LoaderSize,
-  Typography,
-} from '@magmamath/react-native-ui'
-import Animated, { runOnJS, useAnimatedReaction } from 'react-native-reanimated'
-import { useVoiceTranscriptionsDropdownItemAnimation } from '../hooks/useVoiceTranscriptionsDropdownItemAnimation'
-import { useText } from '../../../../i18n/i18n'
-
-type VoiceTranscriptionsDropdownItemProps = {
-  attempt: number
-  content: string
-  isActive: boolean
-  isLoading?: boolean
-  onToggle: (attempt: number) => void
-  scrollToAttempt: (attempt: number) => void
-}
-
-export const VoiceTranscriptionsDropdownItem = memo(
-  ({
-    attempt,
-    content,
-    isActive,
-    isLoading,
-    onToggle,
-    scrollToAttempt,
-  }: VoiceTranscriptionsDropdownItemProps) => {
-    const t = useText()
-    const isActiveRef = useRef(isActive)
-    isActiveRef.current = isActive
-
-    const { contentAnimatedStyle, onLayout, progress } =
-      useVoiceTranscriptionsDropdownItemAnimation(isActive)
-
-    const handleScrollToAttempt = useCallback(
-      (attemptNumber: number) => {
-        if (!isActiveRef.current) return
-        scrollToAttempt(attemptNumber)
-      },
-      [scrollToAttempt],
-    )
-
-    useAnimatedReaction(
-      () => progress.value,
-      (progress) => {
-        if (progress === 1 && isActive) {
-          runOnJS(handleScrollToAttempt)(attempt)
-        }
-      },
-      [progress, attempt, isActive],
-    )
-
-    return (
-      <View style={styles.container}>
-        <Pressable disabled={isActive} style={styles.itemHeader} onPress={() => onToggle(attempt)}>
-          <Button
-            onPress={() => !isActive && onToggle(attempt)}
-            size={ButtonSize.SMALL}
-            variant={ButtonVariant.TERTIARY}
-            style={{
-              text: {
-                textTransform: 'uppercase',
-                color: isActive ? COLORS.NEUTRAL_9 : COLORS.NEUTRAL_7,
-              },
-            }}
-          >
-            {t('voice.attempt', { number: String(attempt) })}
-          </Button>
-        </Pressable>
-        {isLoading ? (
-          <View style={styles.loaderContainer}>
-            <Loader size={LoaderSize.SMALL} color={LoaderColor.BLUE} />
-          </View>
-        ) : (
-          <Animated.View style={contentAnimatedStyle}>
-            <View onLayout={onLayout} style={styles.contentWrapper}>
-              <Typography
-                variant="h8"
-                style={[
-                  styles.itemContent,
-                  {
-                    color: isActive ? COLORS.NEUTRAL_9 : COLORS.NEUTRAL_7,
-                  },
-                ]}
-              >
-                {content}
-              </Typography>
-            </View>
-          </Animated.View>
-        )}
-      </View>
-    )
-  },
-)
-
-const styles = StyleSheet.create({
-  container: {
-    borderTopWidth: 1,
-    borderColor: COLORS.NEUTRAL_3,
-  },
-  itemHeader: {
-    flexDirection: 'row',
-    justifyContent: 'space-between',
-    alignItems: 'center',
-    width: '100%',
-    paddingVertical: 8,
-  },
-  itemContent: {
-    paddingHorizontal: 8,
-  },
-  contentWrapper: {
-    width: '100%',
-    position: 'absolute',
-  },
-  loaderContainer: {
-    justifyContent: 'center',
-    alignItems: 'center',
-    paddingTop: 4,
-    paddingBottom: 8,
-  },
-})

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

@@ -1,40 +0,0 @@
-import { useEffect } from 'react'
-import { LayoutChangeEvent } from 'react-native'
-import {
-  useSharedValue,
-  withTiming,
-  useDerivedValue,
-  useAnimatedStyle,
-  interpolate,
-} from 'react-native-reanimated'
-
-export const useVoiceTranscriptionsDropdownItemAnimation = (isExpanded: boolean) => {
-  const height = useSharedValue(0)
-  const progress = useSharedValue(isExpanded ? 1 : 0)
-
-  useEffect(() => {
-    progress.value = withTiming(isExpanded ? 1 : 0)
-  }, [isExpanded, progress])
-
-  const derivedHeight = useDerivedValue(() => height.value * progress.value, [height, progress])
-
-  const contentAnimatedStyle = useAnimatedStyle(() => {
-    const opacity = interpolate(progress.value, [0, 0.3, 1], [0, 0, 1])
-
-    return {
-      height: derivedHeight.value,
-      opacity,
-      overflow: 'hidden',
-    }
-  }, [progress, derivedHeight])
-
-  const onLayout = (event: LayoutChangeEvent) => {
-    height.value = event.nativeEvent.layout.height
-  }
-
-  return {
-    contentAnimatedStyle,
-    onLayout,
-    progress,
-  }
-}