@magmamath/students-features 1.3.26-rc.9 → 1.3.26

package/src/features/fluency/hooks/useFluencyModePreset.ts

@@ -1,46 +0,0 @@
-import { useUnit } from 'effector-react'
-import { COLORS } from '@magmamath/react-native-ui'
-import type { ButtonColor } from '@magmamath/react-native-ui'
-import { FLUENCY_MODE_PRESETS, FluencyMasteryLevel } from '../fluency.constants'
-import type { LegendItem } from '../fluency.types'
-import { useFluency } from '../context/FluencyContext'
-import { useText } from '../../../i18n/i18n'
-
-type UseFluencyModePresetResult = {
-  symbol: string
-  label: string
-  colors: {
-    level: Record<FluencyMasteryLevel, string>
-    accent: string
-    streak: { gained: string; todayBorder: string }
-    button: ButtonColor
-  }
-  legend: { items: LegendItem[] }
-}
-
-export const useFluencyModePreset = (): UseFluencyModePresetResult => {
-  const t = useText()
-  const { model } = useFluency()
-  const mode = useUnit(model.matrix.$mode)
-  const preset = FLUENCY_MODE_PRESETS[mode]
-
-  const legendItems: LegendItem[] = [
-    { label: t('student.fluency.notStarted'), color: COLORS.NEUTRAL_2, withBorder: true },
-    { label: t('student.fluency.masteryLearning'), color: preset.matrix.levelColors[FluencyMasteryLevel.LEARNING] },
-    { label: t('student.fluency.masteryGrowing'), color: preset.matrix.levelColors[FluencyMasteryLevel.GROWING] },
-    { label: t('student.fluency.masteryStrong'), color: preset.matrix.levelColors[FluencyMasteryLevel.STRONG] },
-    { label: t('student.fluency.masteryMastered'), color: preset.matrix.levelColors[FluencyMasteryLevel.MASTERED] },
-  ]
-
-  return {
-    symbol: preset.symbol,
-    label: t(preset.matrix.operatorLabel),
-    colors: {
-      level: preset.matrix.levelColors,
-      accent: preset.accentColor,
-      streak: preset.header.streakColor,
-      button: preset.buttonColor,
-    },
-    legend: { items: legendItems },
-  }
-}

package/src/features/fluency/hooks/useFluencyNumpad.tsx

@@ -1,139 +0,0 @@
-import React, { useEffect, useRef, useState } from 'react'
-import { COLORS } from '@magmamath/react-native-ui'
-import { ButtonStates } from '@magmamath/react-native-ui'
-import { BackspaceIcon } from '../../../shared/icons/keyboard/BackspaceIcon'
-import { useUnit } from 'effector-react'
-import { isWeb } from '../../../shared/common.constants'
-import { KeyboardKeys } from '../../../lib/constants'
-import { useText } from '../../../i18n/i18n'
-import { useFluency } from '../context/FluencyContext'
-import { MAX_INPUT_LENGTH } from '../fluency.constants'
-
-type UseFluencyNumpadProps = {
-  onSubmit: () => void
-}
-
-type NumpadKey = {
-  key: string
-  title: string | React.ReactNode
-  value: number | KeyboardKeys.BACKSPACE | KeyboardKeys.ENTER
-  customColorScheme?: typeof ACTION_KEY_COLOR_SCHEME
-}
-
-const ACTION_KEY_COLOR_SCHEME = {
-  [ButtonStates.DEFAULT]: {
-    backgroundColor: COLORS.NEUTRAL_3,
-    borderColor: COLORS.NEUTRAL_5,
-    raiseColor: COLORS.NEUTRAL_5,
-    color: COLORS.NEUTRAL_9,
-  },
-  [ButtonStates.HOVER]: {
-    backgroundColor: COLORS.NEUTRAL_2,
-    borderColor: COLORS.NEUTRAL_4,
-    raiseColor: COLORS.NEUTRAL_4,
-    color: COLORS.NEUTRAL_9,
-  },
-}
-
-const NUMPAD_KEYS: NumpadKey[] = [
-  { key: '1', title: '1', value: 1 },
-  { key: '2', title: '2', value: 2 },
-  { key: '3', title: '3', value: 3 },
-  { key: '4', title: '4', value: 4 },
-  { key: '5', title: '5', value: 5 },
-  { key: '6', title: '6', value: 6 },
-  { key: '7', title: '7', value: 7 },
-  { key: '8', title: '8', value: 8 },
-  { key: '9', title: '9', value: 9 },
-  {
-    key: KeyboardKeys.BACKSPACE,
-    title: <BackspaceIcon size={20} color={COLORS.NEUTRAL_9} />,
-    value: KeyboardKeys.BACKSPACE,
-    customColorScheme: ACTION_KEY_COLOR_SCHEME,
-  },
-  { key: '0', title: '0', value: 0 },
-  {
-    key: KeyboardKeys.ENTER,
-    title: 'Enter',
-    value: KeyboardKeys.ENTER,
-    customColorScheme: ACTION_KEY_COLOR_SCHEME,
-  },
-]
-
-const ENTER_COLOR_SCHEME = {
-  [ButtonStates.DEFAULT]: {
-    backgroundColor: COLORS.PRIMARY_GREEN,
-    borderColor: COLORS.GREEN_6,
-    raiseColor: COLORS.GREEN_6,
-    color: COLORS.NEUTRAL_1,
-  },
-  [ButtonStates.HOVER]: {
-    backgroundColor: COLORS.PRIMARY_GREEN,
-    borderColor: COLORS.GREEN_6,
-    raiseColor: COLORS.GREEN_6,
-    color: COLORS.NEUTRAL_1,
-  },
-  [ButtonStates.PRESSED]: {
-    backgroundColor: COLORS.PRIMARY_GREEN,
-    borderColor: COLORS.GREEN_6,
-    raiseColor: COLORS.GREEN_6,
-    color: COLORS.NEUTRAL_1,
-  },
-  [ButtonStates.ACTIVE]: {
-    backgroundColor: COLORS.PRIMARY_GREEN,
-    borderColor: COLORS.GREEN_6,
-    raiseColor: COLORS.GREEN_6,
-    color: COLORS.NEUTRAL_1,
-  },
-}
-
-export const useFluencyNumpad = ({ onSubmit }: UseFluencyNumpadProps) => {
-  const t = useText()
-  const { model } = useFluency()
-  const answer = useUnit(model.solving.$answer)
-  const [pressedKey, setPressedKey] = useState<string | null>(null)
-  const pressedKeyTimeoutRef = useRef<ReturnType<typeof setTimeout>>()
-
-  const pressKey = (key: string) => {
-    if (key === KeyboardKeys.ENTER) {
-      onSubmit()
-      return
-    }
-    if (key === KeyboardKeys.BACKSPACE) {
-      model.solving.setAnswer(answer === null || answer.length <= 1 ? null : answer.slice(0, -1))
-      return
-    }
-    if (answer !== null && answer.length >= MAX_INPUT_LENGTH) return
-    model.solving.setAnswer(answer === null ? key : answer + key)
-  }
-
-  useEffect(() => {
-    if (!isWeb) return
-
-    const handleKeyDown = (event: KeyboardEvent) => {
-      const { key } = event
-      if (!/^\d$/.test(key) && key !== KeyboardKeys.ENTER && key !== KeyboardKeys.BACKSPACE) return
-
-      clearTimeout(pressedKeyTimeoutRef.current)
-      setPressedKey(key)
-      pressedKeyTimeoutRef.current = setTimeout(() => setPressedKey(null), 175)
-      pressKey(key)
-    }
-
-    window.addEventListener('keydown', handleKeyDown)
-    return () => {
-      window.removeEventListener('keydown', handleKeyDown)
-    }
-  }, [answer])
-
-  const options = NUMPAD_KEYS.map(({ value, customColorScheme, ...props }) => ({
-    ...props,
-    title: props.key === KeyboardKeys.ENTER ? t('student.fluency.enter') : props.title,
-    selected: pressedKey === props.key,
-    customColorScheme:
-      props.key === KeyboardKeys.ENTER && answer !== null ? ENTER_COLOR_SCHEME : customColorScheme,
-    onPressIn: () => pressKey(props.key),
-  }))
-
-  return { options }
-}

package/src/features/fluency/hooks/useFluencySolvingPreset.ts

@@ -1,67 +0,0 @@
-import { useUnit } from 'effector-react'
-import { COLORS } from '@magmamath/react-native-ui'
-import type { ButtonColor } from '@magmamath/react-native-ui'
-import { FLUENCY_MODE_PRESETS, FluencyMasteryLevel, type FluencyMode } from '../fluency.constants'
-import type { LegendItem } from '../fluency.types'
-import { useFluency } from '../context/FluencyContext'
-import { useText } from '../../../i18n/i18n'
-
-type UseFluencySolvingPresetParams = {
-  mode?: FluencyMode
-}
-
-type UseFluencySolvingPresetResult = {
-  symbol: string
-  label: string
-  colors: {
-    level: Record<FluencyMasteryLevel, string>
-    accent: string
-    streak: { gained: string; todayBorder: string }
-    button: ButtonColor
-  }
-  legend: { items: LegendItem[] }
-}
-
-export const useFluencySolvingPreset = (
-  params?: UseFluencySolvingPresetParams,
-): UseFluencySolvingPresetResult => {
-  const t = useText()
-  const { model } = useFluency()
-  const { matrixMode, current } = useUnit({
-    matrixMode: model.matrix.$mode,
-    current: model.solving.$current,
-  })
-  const preset = FLUENCY_MODE_PRESETS[params?.mode ?? current?.mode ?? matrixMode]
-
-  const legendItems: LegendItem[] = [
-    { label: t('student.fluency.notStarted'), color: COLORS.NEUTRAL_2, withBorder: true },
-    {
-      label: t('student.fluency.masteryLearning'),
-      color: preset.matrix.levelColors[FluencyMasteryLevel.LEARNING],
-    },
-    {
-      label: t('student.fluency.masteryGrowing'),
-      color: preset.matrix.levelColors[FluencyMasteryLevel.GROWING],
-    },
-    {
-      label: t('student.fluency.masteryStrong'),
-      color: preset.matrix.levelColors[FluencyMasteryLevel.STRONG],
-    },
-    {
-      label: t('student.fluency.masteryMastered'),
-      color: preset.matrix.levelColors[FluencyMasteryLevel.MASTERED],
-    },
-  ]
-
-  return {
-    symbol: preset.symbol,
-    label: t(preset.matrix.operatorLabel),
-    colors: {
-      level: preset.matrix.levelColors,
-      accent: preset.accentColor,
-      streak: preset.header.streakColor,
-      button: preset.buttonColor,
-    },
-    legend: { items: legendItems },
-  }
-}

package/src/features/fluency/hooks/usePreventPageLeave.ts

@@ -1,11 +0,0 @@
-import { useEffect } from 'react'
-import { Platform } from 'react-native'
-
-export const usePreventPageLeave = () => {
-  useEffect(() => {
-    if (Platform.OS !== 'web') return
-    const handleBeforeUnload = (event: BeforeUnloadEvent) => event.preventDefault()
-    window.addEventListener('beforeunload', handleBeforeUnload)
-    return () => window.removeEventListener('beforeunload', handleBeforeUnload)
-  }, [])
-}

package/src/features/fluency/hooks/usePreventWebKeys.ts

@@ -1,24 +0,0 @@
-import { RefObject, useEffect } from 'react'
-import { Platform } from 'react-native'
-
-type UsePreventWebKeysProps = {
-  ref: RefObject<unknown>
-  keys: string[]
-  enabled: boolean
-}
-
-export const usePreventWebKeys = ({ ref, keys, enabled }: UsePreventWebKeysProps) => {
-  useEffect(() => {
-    if (Platform.OS !== 'web' || !enabled) return
-
-    const element = ref.current as unknown as HTMLInputElement
-    if (!element) return
-
-    const preventKeys = (event: KeyboardEvent) => {
-      if (keys.includes(event.key)) event.preventDefault()
-    }
-
-    element.addEventListener('keydown', preventKeys)
-    return () => element.removeEventListener('keydown', preventKeys)
-  }, [ref, keys, enabled])
-}

package/src/features/fluency/hooks/useSuccessSound.ts

@@ -1,20 +0,0 @@
-import { useEffect, useRef } from 'react'
-import { AudioPlayer, createAudioPlayer } from 'expo-audio'
-import SUCCESS_SOUND from '../assets/success.mp3'
-
-export const useSuccessSound = () => {
-  const playerRef = useRef<AudioPlayer | null>(null)
-
-  useEffect(() => {
-    const player = createAudioPlayer(SUCCESS_SOUND)
-    playerRef.current = player
-    return () => player.remove()
-  }, [])
-
-  const play = () => {
-    playerRef.current?.seekTo(0)
-    playerRef.current?.play()
-  }
-
-  return { play }
-}

package/src/features/fluency/index.ts

@@ -1,6 +0,0 @@
-export * from './fluency.constants'
-export * from './fluency.types'
-export * from './fluency.helpers'
-export { Fluency } from './components/Fluency'
-export { FluencySolving } from './components/FluencySolving'
-export { FluencyModel } from './model/FluencyModel'

package/src/features/fluency/model/FluencyApiModel.ts

@@ -1,21 +0,0 @@
-import { createEffect, Effect } from 'effector'
-import type {
-  FluencyAttemptPayload,
-  FluencyAttemptResponse,
-  FluencyModelProps,
-  GetMatrixPayload,
-  GetMatrixResponse,
-  GetWeeklyStatsResponse,
-} from '../fluency.types'
-
-export class FluencyApiModel {
-  public readonly getMatrixFx: Effect<GetMatrixPayload, GetMatrixResponse>
-  public readonly getWeeklyStatsFx: Effect<void, GetWeeklyStatsResponse>
-  public readonly postAttemptFx: Effect<FluencyAttemptPayload, FluencyAttemptResponse>
-
-  constructor(api: FluencyModelProps['api']) {
-    this.getMatrixFx = createEffect(api.getMatrix)
-    this.getWeeklyStatsFx = createEffect(() => api.getWeeklyStats())
-    this.postAttemptFx = createEffect(api.postAttempt)
-  }
-}

package/src/features/fluency/model/FluencyDaysStreakModel.ts

@@ -1,11 +0,0 @@
-import { createStore } from 'effector'
-import type { FluencyApiModel } from './FluencyApiModel'
-import type { GetWeeklyStatsResponse } from '../fluency.types'
-
-export class FluencyDaysStreakModel {
-  public readonly $stats = createStore<GetWeeklyStatsResponse | null>(null)
-
-  constructor(private readonly api: FluencyApiModel) {
-    this.$stats.on(this.api.getWeeklyStatsFx.doneData, (_, data) => data)
-  }
-}

package/src/features/fluency/model/FluencyMatrixModel.ts

@@ -1,20 +0,0 @@
-import { combine, createEvent, createStore, restore } from 'effector'
-import { FluencyMode } from '../fluency.constants'
-import { buildMatrixGrid } from '../fluency.helpers'
-import type { GetMatrixResponse, MatrixGrid } from '../fluency.types'
-import type { FluencyApiModel } from './FluencyApiModel'
-
-export class FluencyMatrixModel {
-  public readonly setMode = createEvent<FluencyMode>()
-  public readonly $mode = restore(this.setMode, FluencyMode.ADDITION)
-
-  public readonly $data = createStore<GetMatrixResponse | null>(null)
-  public readonly $matrix = combine(this.$data, this.$mode, (data, mode): MatrixGrid | null => {
-    if (!data) return null
-    return buildMatrixGrid(data, mode)
-  })
-
-  constructor(api: FluencyApiModel) {
-    this.$data.on(api.getMatrixFx.doneData, (_, data) => data)
-  }
-}

package/src/features/fluency/model/FluencyModel.ts

@@ -1,66 +0,0 @@
-import { createStore, sample } from 'effector'
-import { createGate } from 'effector-react'
-import { not } from 'patronum/not'
-import { FluencyDaysStreakModel } from './FluencyDaysStreakModel'
-import { FluencyMatrixModel } from './FluencyMatrixModel'
-import { FluencyApiModel } from './FluencyApiModel'
-import { FluencySolvingModel } from './FluencySolvingModel'
-import { MatrixConfig } from '../fluency.constants'
-import type {
-  FluencyAttemptPayload,
-  FluencyConfig,
-  FluencyModelGateProps,
-  FluencyModelProps,
-} from '../fluency.types'
-
-export class FluencyModel {
-  public readonly gate = createGate<FluencyModelGateProps>()
-  public readonly $config = createStore<FluencyConfig | null>(null)
-
-  public readonly api: FluencyApiModel
-  public readonly streak: FluencyDaysStreakModel
-  public readonly matrix: FluencyMatrixModel
-  public readonly solving: FluencySolvingModel
-
-  constructor({ api }: FluencyModelProps) {
-    this.api = new FluencyApiModel(api)
-    this.streak = new FluencyDaysStreakModel(this.api)
-    this.matrix = new FluencyMatrixModel(this.api)
-    this.solving = new FluencySolvingModel(this.matrix)
-
-    this.init()
-  }
-
-  private init() {
-    sample({
-      clock: this.gate.open,
-      fn: ({ config }) => config,
-      target: this.$config,
-    })
-
-    sample({
-      clock: this.gate.open,
-      filter: not(this.api.getMatrixFx.pending),
-      fn: ({ config }) => ({ grade: config.grade }),
-      target: this.api.getMatrixFx,
-    })
-
-    sample({
-      clock: this.gate.open,
-      filter: not(this.api.getWeeklyStatsFx.pending),
-      target: this.api.getWeeklyStatsFx,
-    })
-
-    sample({
-      clock: this.solving.flushAttempts,
-      source: this.$config,
-      filter: Boolean,
-      fn: (config, attempts): FluencyAttemptPayload => ({
-        grade: config.grade,
-        attempts,
-        matrixConfig: MatrixConfig.STANDARD,
-      }),
-      target: this.api.postAttemptFx,
-    })
-  }
-}

package/src/features/fluency/model/FluencySolvingModel.ts

@@ -1,186 +0,0 @@
-import { createEvent, createStore, restore, sample } from 'effector'
-import {
-  AttemptStatus,
-  FLUSH_ATTEMPTS_COUNT,
-  FluencyMode,
-  SESSION_LENGTH,
-  TIME_THRESHOLD_MS,
-} from '../fluency.constants'
-import {
-  calculateNextBox,
-  selectNextFact,
-  toSolvingFacts,
-} from '../components/fluency-solving/fluencySolving.helpers'
-import type {
-  QuestionOutcome,
-  SolvingFact,
-} from '../components/fluency-solving/fluencySolving.types'
-import type { FluencyAttemptItem } from '../fluency.types'
-import type { FluencyMatrixModel } from './FluencyMatrixModel'
-import { createAction } from 'effector-action'
-import { GetMatrixResponse } from '@magmamath/students-features'
-
-export class FluencySolvingModel {
-  public readonly reset = createEvent()
-
-  public readonly start = createEvent<FluencyMode | void>()
-  public readonly submit = createEvent()
-  public readonly setAnswer = createEvent<string | null>()
-  public readonly setSessionCompleted = createEvent<boolean>()
-  public readonly updateFact = createEvent<SolvingFact>()
-  public readonly flushAttempts = createEvent<FluencyAttemptItem[]>()
-
-  public readonly $answer = restore(this.setAnswer, null).reset(this.reset)
-  public readonly $current = createStore<SolvingFact | null>(null).reset(this.reset)
-  public readonly $outcomes = createStore<QuestionOutcome[]>([]).reset(this.reset)
-  public readonly $facts = createStore<SolvingFact[]>([])
-    .on(this.updateFact, (facts, updatedFact) =>
-      facts.map((fact) => (fact.id === updatedFact.id ? updatedFact : fact)),
-    )
-    .reset(this.reset)
-
-  public readonly $sessionDurationMs = createStore(0).reset(this.reset)
-  public readonly $completedDurationMs = createStore(0).reset(this.reset)
-  public readonly $timeSpentInCurrentMs = createStore(0).reset(this.reset)
-
-  public readonly $isSessionComplete = restore(this.setSessionCompleted, false).reset(this.reset)
-  public readonly $pendingAttempts = createStore<FluencyAttemptItem[]>([])
-    .reset(this.flushAttempts)
-    .reset(this.reset)
-
-  constructor(private readonly matrixModel: FluencyMatrixModel) {
-    this.setupStartTrigger()
-    this.setupSubmitTrigger()
-    this.setupFlushTrigger()
-  }
-
-  private setupStartTrigger() {
-    createAction(this.start, {
-      source: { data: this.matrixModel.$data },
-      target: {
-        $facts: this.$facts,
-        $current: this.$current,
-        $answer: this.$answer,
-        $outcomes: this.$outcomes,
-        $isSessionComplete: this.$isSessionComplete,
-        $pendingAttempts: this.$pendingAttempts,
-        $sessionDurationMs: this.$sessionDurationMs,
-        $completedDurationMs: this.$completedDurationMs,
-        $timeSpentInCurrentMs: this.$timeSpentInCurrentMs,
-      },
-      fn: (target, source, mode) => {
-        if (!source.data) return
-
-        const facts = this.getFactsFromData(source.data, mode || undefined)
-        target.$facts(facts)
-        target.$current(selectNextFact(facts, Date.now()))
-        target.$answer(null)
-        target.$outcomes([])
-        target.$isSessionComplete(false)
-        target.$pendingAttempts([])
-        target.$sessionDurationMs(Date.now())
-        target.$completedDurationMs(0)
-        target.$timeSpentInCurrentMs(Date.now())
-      },
-    })
-  }
-
-  private setupSubmitTrigger() {
-    createAction(this.submit, {
-      source: {
-        answer: this.$answer,
-        facts: this.$facts,
-        current: this.$current,
-        outcomes: this.$outcomes,
-        timeSpentInCurrentMs: this.$timeSpentInCurrentMs,
-        sessionDurationMs: this.$sessionDurationMs,
-        pendingAttempts: this.$pendingAttempts,
-      },
-      target: {
-        $current: this.$current,
-        $outcomes: this.$outcomes,
-        $answer: this.$answer,
-        $sessionDurationMs: this.$sessionDurationMs,
-        $completedDurationMs: this.$completedDurationMs,
-        $timeSpentInCurrentMs: this.$timeSpentInCurrentMs,
-        $pendingAttempts: this.$pendingAttempts,
-        update: this.updateFact,
-        setSessionCompleted: this.setSessionCompleted,
-      },
-      fn: (target, source) => {
-        if (!source.facts || !source.current) return
-
-        const timeTakenToSolveFactMs = Date.now() - source.timeSpentInCurrentMs
-        const isCorrect = source.answer !== null && Number(source.answer) === source.current.answer
-        const isFast = timeTakenToSolveFactMs <= TIME_THRESHOLD_MS
-        const isLastQuestion = source.outcomes.length + 1 >= SESSION_LENGTH
-
-        const nextBox = calculateNextBox({
-          isFast,
-          isCorrect,
-          currentBox: source.current.box,
-          sessionStartBox: source.current.sessionStartBox,
-          hasFailedThisSession: source.current.hasFailedThisSession,
-        })
-
-        const updatedFact = {
-          ...source.current,
-          box: nextBox,
-          lastSeenMs: Date.now(),
-          hasFailedThisSession: source.current.hasFailedThisSession || !isCorrect,
-          attemptsCount: source.current.attemptsCount + 1,
-          correctCount: source.current.correctCount + (isCorrect ? 1 : 0),
-        }
-
-        const updatedFacts = source.facts.map((f) => (f.id === updatedFact.id ? updatedFact : f))
-        target.update(updatedFact)
-
-        const attemptItem: FluencyAttemptItem = {
-          factId: source.current.id,
-          status: isCorrect ? AttemptStatus.CORRECT : AttemptStatus.INCORRECT,
-          startedAt: new Date(source.timeSpentInCurrentMs).toISOString(),
-          timeToSolve: timeTakenToSolveFactMs,
-          boxAfter: nextBox,
-        }
-        target.$pendingAttempts([...source.pendingAttempts, attemptItem])
-        target.$outcomes([
-          ...source.outcomes,
-          {
-            factId: source.current.id,
-            status: isCorrect ? AttemptStatus.CORRECT : AttemptStatus.INCORRECT,
-            answer: source.answer,
-            numbers: source.current.numbers,
-            mode: source.current.mode,
-          },
-        ])
-
-        if (isLastQuestion) {
-          target.$completedDurationMs(Date.now() - source.sessionDurationMs)
-          target.$sessionDurationMs(0)
-          target.setSessionCompleted(true)
-          return
-        }
-
-        target.$current(selectNextFact(updatedFacts, Date.now()))
-        target.$answer(null)
-        target.$timeSpentInCurrentMs(Date.now())
-      },
-    })
-  }
-
-  private setupFlushTrigger() {
-    sample({
-      clock: this.$pendingAttempts,
-      filter: (attempts) => attempts.length >= FLUSH_ATTEMPTS_COUNT,
-      target: this.flushAttempts,
-    })
-  }
-
-  private getFactsFromData(data: GetMatrixResponse, mode?: FluencyMode) {
-    return mode
-      ? toSolvingFacts(data.operations[mode].facts, mode)
-      : Object.entries(data.operations).flatMap(([key, { facts }]) =>
-          toSolvingFacts(facts, key as FluencyMode),
-        )
-  }
-}

package/src/lib/components/GradientView.tsx

@@ -1,63 +0,0 @@
-import React from 'react'
-import { View, Platform } from 'react-native'
-import type { StyleProp, ViewStyle } from 'react-native'
-
-type Point = { x: number; y: number }
-
-type GradientViewProps = {
-  colors: string[]
-  start?: Point
-  end?: Point
-  locations?: number[]
-  style?: StyleProp<ViewStyle>
-  pointerEvents?: 'none' | 'box-none' | 'box-only' | 'auto'
-  children?: React.ReactNode
-}
-
-const buildCssGradient = (colors: string[], start: Point, end: Point, locations?: number[]): string => {
-  const angle = Math.round(Math.atan2(end.x - start.x, -(end.y - start.y)) * (180 / Math.PI))
-  const stops = colors
-    .map((color, i) => {
-      const pct = locations
-        ? `${Math.round(locations[i] * 100)}%`
-        : `${Math.round((i / (colors.length - 1)) * 100)}%`
-      return `${color} ${pct}`
-    })
-    .join(', ')
-  return `linear-gradient(${angle}deg, ${stops})`
-}
-
-export const GradientView = ({
-  colors,
-  start = { x: 0, y: 0 },
-  end = { x: 0, y: 1 },
-  locations,
-  style,
-  pointerEvents,
-  children,
-}: GradientViewProps) => {
-  if (Platform.OS === 'web') {
-    return (
-      <View
-        pointerEvents={pointerEvents}
-        style={[style, { backgroundImage: buildCssGradient(colors, start, end, locations) } as any]}
-      >
-        {children}
-      </View>
-    )
-  }
-
-  const { LinearGradient } = require('expo-linear-gradient')
-  return (
-    <LinearGradient
-      colors={colors}
-      start={start}
-      end={end}
-      locations={locations}
-      style={style}
-      pointerEvents={pointerEvents}
-    >
-      {children}
-    </LinearGradient>
-  )
-}