@magmamath/students-features 1.5.0 → 1.5.1

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

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

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

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

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

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

@@ -0,0 +1,20 @@
+import { createEffect, Effect } from 'effector'
+import type {
+  FluencyAttemptPayload,
+  FluencyModelProps,
+  GetMatrixPayload,
+  GetMatrixResponse,
+  GetWeeklyStatsResponse,
+} from '../shared/fluency.types'
+
+export class FluencyApiModel {
+  public readonly getMatrixFx: Effect<GetMatrixPayload, GetMatrixResponse>
+  public readonly getWeeklyStatsFx: Effect<void, GetWeeklyStatsResponse>
+  public readonly postAttemptFx: Effect<FluencyAttemptPayload, void>
+
+  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

@@ -0,0 +1,11 @@
+import { createStore } from 'effector'
+import type { FluencyApiModel } from './FluencyApiModel'
+import type { GetWeeklyStatsResponse } from '../shared/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

@@ -0,0 +1,20 @@
+import { combine, createEvent, createStore, restore } from 'effector'
+import { FluencyMode } from '../shared/fluency.constants'
+import { buildMatrixGrid } from '../shared/fluency.helpers'
+import type { GetMatrixResponse, MatrixGrid } from '../shared/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

@@ -0,0 +1,90 @@
+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 { FluencyStatus, MatrixConfig } from '../shared/fluency.constants'
+import { allFactsEmpty } from '../shared/fluency.helpers'
+import type {
+  FluencyAttemptPayload,
+  FluencyConfig,
+  FluencyModelGateProps,
+  FluencyModelProps,
+} from '../shared/fluency.types'
+
+export class FluencyModel {
+  public readonly gate = createGate<FluencyModelGateProps>()
+  public readonly $config = createStore<FluencyConfig | null>(null)
+  public readonly $status = createStore<FluencyStatus | 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.$config)
+
+    this.init()
+    this.setupStatusTracking()
+  }
+
+  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,
+    })
+  }
+
+  private setupStatusTracking() {
+    sample({
+      clock: this.gate.open,
+      fn: () => null as FluencyStatus | null,
+      target: this.$status,
+    })
+
+    sample({
+      clock: [this.api.getMatrixFx.fail, this.api.getWeeklyStatsFx.fail],
+      fn: () => FluencyStatus.ERROR,
+      target: this.$status,
+    })
+
+    sample({
+      clock: this.api.getMatrixFx.doneData,
+      filter: allFactsEmpty,
+      fn: () => FluencyStatus.EMPTY,
+      target: this.$status,
+    })
+  }
+}

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

@@ -0,0 +1,183 @@
+import { createEvent, createStore, restore, sample } from 'effector'
+import type { Store } from 'effector'
+import {
+  AttemptStatus,
+  FLUSH_ATTEMPTS_COUNT,
+  FluencyMode,
+  SESSION_LENGTH,
+  getTimeThresholdByGrade,
+} from '../shared/fluency.constants'
+import { calculateNextBox, selectNextFact, toSolvingFacts } from '../shared/fluencySolving.helpers'
+import type { QuestionOutcome, SolvingFact } from '../shared/fluencySolving.types'
+import type { FluencyAttemptItem, FluencyConfig, GetMatrixResponse } from '../shared/fluency.types'
+import type { FluencyMatrixModel } from './FluencyMatrixModel'
+import { createAction } from 'effector-action'
+
+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,
+    private readonly $config: Store<FluencyConfig | null>,
+  ) {
+    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,
+        config: this.$config,
+      },
+      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 <= getTimeThresholdByGrade(source.config?.grade)
+        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/features/fluency/shared/fluency.constants.ts

@@ -0,0 +1,113 @@
+import { ButtonColor, COLORS, SelectOptionColor } from '@magmamath/react-native-ui'
+import { createFluencyMode } from './fluency.helpers'
+import type { FluencyColorPalette, FluencyModeConfig, FluencyModePreset } from './fluency.types'
+
+export const MAX_INPUT_LENGTH = 3
+export const SESSION_LENGTH = 20
+export const FLUSH_ATTEMPTS_COUNT = 5
+
+export const getTimeThresholdByGrade = (grade?: number): number => {
+  if (grade == null || grade >= 4) return 4000
+  if (grade >= 2) return 5000
+  return 6000
+}
+
+export enum FluencyMode {
+  ADDITION = 'addition',
+  SUBTRACTION = 'subtraction',
+  MULTIPLICATION = 'multiplication',
+  DIVISION = 'division',
+}
+
+export enum FluencyMasteryLevel {
+  NOT_STARTED = 0,
+  LEARNING = 1,
+  GROWING = 2,
+  STRONG = 3,
+  MASTERED = 4,
+}
+
+export enum FluencyColorFamily {
+  GREEN = 'GREEN',
+  ORANGE = 'ORANGE',
+  BLUE = 'BLUE',
+  PURPLE = 'PURPLE',
+}
+
+export enum StreakStatus {
+  MISSED = 'missed',
+  GAINED = 'gained',
+  TODAY = 'today',
+  TODAY_GAINED = 'today_gained',
+}
+
+export enum AttemptStatus {
+  CORRECT = 'correct',
+  INCORRECT = 'incorrect',
+  SKIPPED = 'skipped',
+}
+
+export enum MatrixConfig {
+  STANDARD = 'standard',
+}
+
+export const COLOR_FAMILY_PALETTES: Record<FluencyColorFamily, FluencyColorPalette> = {
+  [FluencyColorFamily.GREEN]: {
+    shades: [COLORS.GREEN_2, COLORS.GREEN_3, COLORS.PRIMARY_GREEN, COLORS.GREEN_6],
+    button: ButtonColor.GREEN,
+    select: SelectOptionColor.GREEN,
+  },
+  [FluencyColorFamily.ORANGE]: {
+    shades: [COLORS.ORANGE_2, COLORS.ORANGE_3, COLORS.PRIMARY_ORANGE, COLORS.ORANGE_6],
+    button: ButtonColor.ORANGE,
+    select: SelectOptionColor.ORANGE,
+  },
+  [FluencyColorFamily.BLUE]: {
+    shades: [COLORS.BLUE_2, COLORS.BLUE_3, COLORS.PRIMARY_BLUE, COLORS.BLUE_6],
+    button: ButtonColor.BLUE,
+    select: SelectOptionColor.BLUE,
+  },
+  [FluencyColorFamily.PURPLE]: {
+    shades: [COLORS.PURPLE_2, COLORS.PURPLE_3, COLORS.PRIMARY_PURPLE, COLORS.PURPLE_6],
+    button: ButtonColor.PURPLE,
+    select: SelectOptionColor.PURPLE,
+  },
+}
+
+export const FLUENCY_MODES: readonly FluencyModeConfig[] = [
+  createFluencyMode({
+    mode: FluencyMode.ADDITION,
+    label: 'student.fluency.addition',
+    symbol: '+',
+    colorFamily: FluencyColorFamily.GREEN,
+  }),
+  createFluencyMode({
+    mode: FluencyMode.SUBTRACTION,
+    label: 'student.fluency.subtraction',
+    symbol: '−',
+    colorFamily: FluencyColorFamily.ORANGE,
+  }),
+  createFluencyMode({
+    mode: FluencyMode.MULTIPLICATION,
+    label: 'student.fluency.multiplication',
+    symbol: '×',
+    colorFamily: FluencyColorFamily.BLUE,
+  }),
+  createFluencyMode({
+    mode: FluencyMode.DIVISION,
+    label: 'student.fluency.division',
+    symbol: '÷',
+    colorFamily: FluencyColorFamily.PURPLE,
+  }),
+]
+
+export const FLUENCY_MODE_PRESETS: Record<FluencyMode, FluencyModePreset> = Object.fromEntries(
+  FLUENCY_MODES.map(({ mode, preset }) => [mode, preset]),
+) as Record<FluencyMode, FluencyModePreset>
+
+export const ONE_DAY_MS = 86_400_000
+
+export enum FluencyStatus {
+  ERROR = 'ERROR',
+  EMPTY = 'EMPTY',
+}

package/src/features/fluency/shared/fluency.helpers.ts

@@ -0,0 +1,137 @@
+import { COLORS } from '@magmamath/react-native-ui'
+import {
+  FluencyColorFamily,
+  FluencyMasteryLevel,
+  FluencyMode,
+  COLOR_FAMILY_PALETTES,
+  StreakStatus,
+  ONE_DAY_MS,
+} from './fluency.constants'
+import type {
+  FluencyModeConfig,
+  GetMatrixResponse,
+  GetWeeklyStatsResponse,
+  GridCell,
+  MatrixGrid,
+} from './fluency.types'
+import type { TranslationKey } from '../../../i18n/i18n'
+
+type CreateFluencyModeParams = {
+  mode: FluencyMode
+  label: TranslationKey
+  symbol: string
+  colorFamily: FluencyColorFamily
+}
+
+export const createFluencyMode = ({
+  mode,
+  label,
+  symbol,
+  colorFamily,
+}: CreateFluencyModeParams): FluencyModeConfig => {
+  const palette = COLOR_FAMILY_PALETTES[colorFamily]
+  const [learning, growing, strong, mastered] = palette.shades
+
+  return {
+    mode,
+    label,
+    symbol,
+    select: palette.select,
+    preset: {
+      buttonColor: palette.button,
+      symbol,
+      accentColor: strong,
+      header: {
+        streakColor: { gained: growing, todayBorder: strong },
+      },
+      matrix: {
+        operatorLabel: label,
+        levelColors: {
+          [FluencyMasteryLevel.NOT_STARTED]: COLORS.NEUTRAL_2,
+          [FluencyMasteryLevel.LEARNING]: learning,
+          [FluencyMasteryLevel.GROWING]: growing,
+          [FluencyMasteryLevel.STRONG]: strong,
+          [FluencyMasteryLevel.MASTERED]: mastered,
+        },
+      },
+    },
+  }
+}
+
+export const buildMatrixGrid = (data: GetMatrixResponse, mode: FluencyMode): MatrixGrid => {
+  const facts = Object.values(data.operations[mode].facts)
+  const maxRow = Math.max(0, ...facts.map((f) => f.position.row))
+  const maxColumn = Math.max(0, ...facts.map((f) => f.position.column))
+  const isDivision = mode === FluencyMode.DIVISION
+  const isSubtraction = mode === FluencyMode.SUBTRACTION
+  const isCommutative = mode === FluencyMode.ADDITION || mode === FluencyMode.MULTIPLICATION
+
+  const factAt = (row: number, col: number) =>
+    facts.find((f) => f.position.row === row && f.position.column === col)
+
+  // Division columns are 1-indexed in the API (÷1, ÷2...); all others are 0-indexed.
+  // Subtraction rows: the API stores position.row = result (like division stores quotient),
+  // but we display a minuend×subtrahend grid, so we derive row count from the max minuend
+  // stored in fact.numbers[0] and look up each cell by result = minuend − subtrahend.
+  const maxMinuend = isSubtraction ? Math.max(0, ...facts.map((f) => f.numbers[0])) : maxRow
+  const rowNumbers = Array.from({ length: maxMinuend + 1 }, (_, i) => i)
+  const columnNumbers = isDivision
+    ? Array.from({ length: maxColumn }, (_, i) => i + 1)
+    : Array.from({ length: maxColumn + 1 }, (_, i) => i)
+
+  const headerRow: GridCell[] = [
+    { isHeader: false, isEmpty: false, label: null, box: null, numbers: null },
+    ...columnNumbers.map(
+      (col): GridCell => ({ isHeader: true, isEmpty: false, label: col, box: null, numbers: null }),
+    ),
+  ]
+
+  const dataRows: GridCell[][] = rowNumbers.map((row) => [
+    { isHeader: true, isEmpty: false, label: row, box: null, numbers: null },
+    ...columnNumbers.map((col): GridCell => {
+      if (isSubtraction && col > row) {
+        return { isHeader: false, isEmpty: true, label: null, box: null, numbers: null }
+      }
+
+      // Subtraction: row=minuend, col=subtrahend — look up by result=minuend−subtrahend
+      const fact = isSubtraction ? factAt(row - col, col) : factAt(row, col)
+      const mirrorFact = isCommutative ? factAt(col, row) : null
+      const primaryBox = fact?.box ?? null
+      const mirrorBox = mirrorFact?.box ?? null
+      const effectiveBox =
+        primaryBox !== null && mirrorBox !== null
+          ? Math.max(primaryBox, mirrorBox)
+          : (primaryBox ?? mirrorBox)
+      const numbers: readonly [number, number] =
+        fact?.numbers ?? (isDivision ? [row * col, col] : [row, col])
+      return {
+        isHeader: false,
+        isEmpty: false,
+        label: null,
+        box: effectiveBox,
+        numbers,
+      }
+    }),
+  ])
+
+  return [headerRow, ...dataRows]
+}
+
+export const allFactsEmpty = (response: GetMatrixResponse): boolean =>
+  Object.values(response.operations).every((op) => Object.keys(op.facts).length === 0)
+
+export const generateStreakDates = (stats: GetWeeklyStatsResponse) => {
+  const todayMs = new Date().setHours(0, 0, 0, 0)
+  const startMs = new Date(stats.weekStart).setHours(0, 0, 0, 0)
+  const practiced = new Set(stats.practicedDates.map((d) => new Date(d).setHours(0, 0, 0, 0)))
+
+  return [0, 1, 2, 3, 4].map((i) => {
+    const dayMs = startMs + i * ONE_DAY_MS
+    const isPracticed = practiced.has(dayMs)
+    const isToday = dayMs === todayMs
+    if (isPracticed && isToday) return StreakStatus.TODAY_GAINED
+    if (isPracticed) return StreakStatus.GAINED
+    if (isToday) return StreakStatus.TODAY
+    return StreakStatus.MISSED
+  })
+}