@magmamath/students-features 1.2.0 → 1.2.1-rc.10

package/src/features/pmProgress/model/PmProgressModel.ts

@@ -0,0 +1,50 @@
+import { sample } from 'effector'
+import { createGate } from 'effector-react'
+import { PmProgressGateProps } from '../shared/pmProgress.types'
+import { PmProgressApi, type PmProgressApiProps } from './PmProgressApi'
+import { PmTreeModel } from './PmTreeModel'
+import { PmInsightsModel } from './PmInsightsModel'
+import { PmRecommendationsModel } from './PmRecommendationsModel'
+import { PmSolvingFlowModel } from './PmSolvingFlowModel'
+
+type PmProgressModelProps = {
+  api: PmProgressApiProps
+}
+
+export class PmProgressModel {
+  public readonly gate = createGate<PmProgressGateProps>()
+
+  public readonly api: PmProgressApi
+  public readonly tree: PmTreeModel
+  public readonly insights: PmInsightsModel
+  public readonly recommendations: PmRecommendationsModel
+  public readonly solving: PmSolvingFlowModel
+
+  constructor({ api }: PmProgressModelProps) {
+    this.api = new PmProgressApi(api)
+    this.insights = new PmInsightsModel(this.api)
+    this.tree = new PmTreeModel(this.api)
+    this.recommendations = new PmRecommendationsModel(this.api)
+    this.solving = new PmSolvingFlowModel(this.tree, this.recommendations)
+
+    this.init()
+  }
+
+  private init() {
+    sample({
+      clock: this.gate.open,
+      target: [this.tree.initTreeFx, this.api.getUserInsightsFx],
+    })
+
+    sample({
+      clock: this.tree.initTreeFx.done,
+      fn: ({ result: [tree] }) => tree,
+      target: this.recommendations.initRecommendationsFx,
+    })
+
+    sample({
+      clock: this.gate.close,
+      target: this.solving.reset,
+    })
+  }
+}

package/src/features/pmProgress/model/PmRecommendationsModel.ts

@@ -0,0 +1,47 @@
+import { PmProgressApi } from './PmProgressApi'
+import { createEffect, createStore } from 'effector'
+import { Recommendations, RecsResponse, TreeMappingResponse } from '../shared/pmProgress.types'
+import { RECOMMENDATIONS_LIMIT_PARAM, SolvingFlow } from '../shared/pmProgress.constants'
+
+const INITIAL_RECOMMENDATION_STATE: Recommendations = { items: [], offset: 0, limit: 0, total: 0 }
+
+export class PmRecommendationsModel {
+  public readonly $teacher = createStore<Recommendations>(INITIAL_RECOMMENDATION_STATE)
+  public readonly $magma = createStore<Recommendations>(INITIAL_RECOMMENDATION_STATE)
+
+  constructor(private readonly api: PmProgressApi) {
+    this.$teacher.on(this.fetchTeacherRecsFx.doneData, (_, data) => data)
+    this.$magma.on(this.fetchMagmaRecsFx.doneData, (_, data) => data)
+  }
+
+  public readonly fetchTeacherRecsFx = createEffect((tree: TreeMappingResponse) =>
+    this.fetchRecs(tree, SolvingFlow.TEACHER, () =>
+      this.api.getTeacherRecsFx({ limit: RECOMMENDATIONS_LIMIT_PARAM }),
+    ),
+  )
+
+  public readonly fetchMagmaRecsFx = createEffect((tree: TreeMappingResponse) =>
+    this.fetchRecs(tree, SolvingFlow.MAGMA, () =>
+      this.api.getMagmaRecsFx({ limit: RECOMMENDATIONS_LIMIT_PARAM }),
+    ),
+  )
+
+  public readonly initRecommendationsFx = createEffect((tree: TreeMappingResponse) =>
+    Promise.all([this.fetchTeacherRecsFx(tree), this.fetchMagmaRecsFx(tree)]),
+  )
+
+  private fetchRecs = async (
+    tree: TreeMappingResponse,
+    type: SolvingFlow,
+    fetcher: () => Promise<RecsResponse>,
+  ) => {
+    const recommendations = await fetcher()
+    return {
+      ...recommendations,
+      items: recommendations.items.flatMap(({ skillId }) => {
+        const skill = tree.skillsMapping[skillId]
+        return skill ? [{ ...skill, type }] : []
+      }),
+    }
+  }
+}

package/src/features/pmProgress/model/PmSolvingFlowModel.ts

@@ -0,0 +1,105 @@
+import { createEvent, restore } from 'effector'
+import { SolvingFlow } from '../shared/pmProgress.constants'
+
+import type { PmTreeModel } from './PmTreeModel'
+import type { PmRecommendationsModel } from './PmRecommendationsModel'
+import {
+  MagmaQueueData,
+  QueueBuilderData,
+  Skill,
+  StandardQueueData,
+  StartSolvingProps,
+  TeacherQueueData,
+} from '../shared/pmProgress.types'
+import {
+  getAllUncompletedSkills,
+  getUncompletedSkillsFromDomain,
+  getUncompletedSkillsFromStandard,
+  shiftToBeginningOfArray,
+  withoutDuplicates,
+} from '../shared/pmProgress.helpers'
+
+export class PmSolvingFlowModel {
+  public readonly reset = createEvent()
+
+  public readonly setQueue = createEvent<Skill[]>()
+  public readonly advance = createEvent()
+
+  public readonly $queue = restore(this.setQueue, [])
+    .on(this.advance, (queue) => queue.slice(1))
+    .reset(this.reset)
+
+  constructor(
+    private readonly treeModel: PmTreeModel,
+    private readonly recommendationsModel: PmRecommendationsModel,
+  ) {}
+
+  public async start(props: StartSolvingProps): Promise<Skill> {
+    const buildQueue = await this.getBuilder(props)
+    const queue = buildQueue[props.type]()
+
+    this.setQueue(queue)
+    console.log('queue', queue)
+
+    return queue[0]
+  }
+
+  public async next() {
+    this.advance()
+    return this.$queue.getState()[0]
+  }
+
+  private buildTeacherQueue({ domains, context, skillId }: TeacherQueueData): Skill[] {
+    const teacherSkills = this.recommendationsModel.$teacher.getState().items
+    const magmaRecommendations = this.recommendationsModel.$magma.getState().items
+    const fromUncompletedDomains = getAllUncompletedSkills(domains, context.tree.skillsMapping)
+
+    const teacherRecommendations = skillId
+      ? shiftToBeginningOfArray(skillId, teacherSkills)
+      : teacherSkills
+
+    return withoutDuplicates([
+      ...teacherRecommendations,
+      ...magmaRecommendations,
+      ...fromUncompletedDomains,
+    ])
+  }
+
+  private buildMagmaQueue({ domains, context }: MagmaQueueData): Skill[] {
+    const magmaRecommendations = this.recommendationsModel.$magma.getState().items
+    const fromUncompletedDomains = getAllUncompletedSkills(domains, context.tree.skillsMapping)
+    return withoutDuplicates([...magmaRecommendations, ...fromUncompletedDomains])
+  }
+
+  private buildStandardQueue({ domains, context, standardId }: StandardQueueData): Skill[] {
+    const domain = domains.find((d) => d.standards.some((s) => s.standardId === standardId))
+    if (!domain) return []
+
+    const standard = domain.standards.find((s) => s.standardId === standardId)
+    if (!standard) return []
+
+    const fromStandard = getUncompletedSkillsFromStandard(standard, context.tree.skillsMapping)
+    const fromDomain = getUncompletedSkillsFromDomain(
+      domain,
+      context.tree.skillsMapping,
+      standardId,
+    )
+    const fromOtherDomains = domains
+      .filter((d) => d !== domain)
+      .flatMap((domain) => getUncompletedSkillsFromDomain(domain, context.tree.skillsMapping))
+
+    return withoutDuplicates([...fromStandard, ...fromDomain, ...fromOtherDomains])
+  }
+
+  private async getBuilder(props: StartSolvingProps): Promise<Record<SolvingFlow, () => Skill[]>> {
+    const domains = this.treeModel.$domains.getState()
+    const context = await this.treeModel.getTreeContextFx()
+    const data: QueueBuilderData = { domains, context, ...props }
+
+    return {
+      [SolvingFlow.TEACHER]: () => this.buildTeacherQueue(data as TeacherQueueData),
+      [SolvingFlow.MAGMA]: () => this.buildMagmaQueue(data as MagmaQueueData),
+      [SolvingFlow.STANDARD]: () => this.buildStandardQueue(data as StandardQueueData),
+    }
+  }
+}

package/src/features/pmProgress/model/PmTreeModel.ts

@@ -0,0 +1,148 @@
+import { attach, createEffect, createEvent, createStore, restore, sample } from 'effector'
+import { createAction } from 'effector-action'
+import {
+  Domain,
+  Grade,
+  PmProgressGateProps,
+  SetupInitialGradeProps,
+  StatsResponse,
+  GetTreeContextFxParams,
+  TreeMappingResponse,
+  User,
+} from '../shared/pmProgress.types'
+import { PmProgressApi } from './PmProgressApi'
+import { enhanceProgressMatrixData } from '@matteappen/skills-utils'
+import {
+  getDomainStructure,
+  getInitialPmGrade,
+  isTreeDataReady,
+} from '../shared/pmProgress.helpers'
+import { getText } from '../../../shared/translation/helpers'
+
+function getTreeGrades(tree: TreeMappingResponse, user: User): Grade[] {
+  const lockedGrades = new Set(user.setting.practiceModeLockedGrades)
+
+  const gradeNodes = Object.values(tree.treeMapping).filter(
+    (node) => node?.type === 'grade' && node.attributes.grade !== null,
+  )
+
+  const uniqueSortedGrades = [...new Set(gradeNodes.map((node) => node.attributes.grade))].sort(
+    (a, b) => a - b,
+  )
+
+  function getGradeName(grade: number): string {
+    if (grade === -1) return getText('pmProgress.gradeOther')
+    if (grade === 0) return `${getText('pmProgress.grade')} ${getText('pmProgress.gradeK')}`
+    return `${getText('pmProgress.grade')} ${grade}`
+  }
+
+  return uniqueSortedGrades.map((grade) => ({
+    name: getGradeName(grade),
+    value: grade,
+    isLocked: lockedGrades.has(grade),
+  }))
+}
+
+export class PmTreeModel {
+  private readonly $tree = createStore<TreeMappingResponse | null>(null)
+  private readonly $stats = createStore<StatsResponse | null>(null)
+  private readonly $user = createStore<User | null>(null)
+
+  private readonly setupInitialGrade = createEvent<SetupInitialGradeProps>()
+  private readonly setDomains = createEvent<Domain[]>()
+  public readonly setGrade = createEvent<number | null>()
+  public readonly setHighlightedId = createEvent<string>()
+
+  public readonly $grade = restore(this.setGrade, null)
+  public readonly $domains = restore(this.setDomains, [])
+  public readonly $grades = createStore<Grade[]>([])
+  public readonly $highlightedId = createStore<string | null>(null).on(
+    this.setHighlightedId,
+    (highlightedId, idToHighlight) => (highlightedId === idToHighlight ? null : idToHighlight),
+  )
+
+  constructor(private readonly api: PmProgressApi) {
+    createAction(this.initTreeFx.done, {
+      target: {
+        $tree: this.$tree,
+        $stats: this.$stats,
+        $user: this.$user,
+        $grades: this.$grades,
+        setupInitialGrade: this.setupInitialGrade,
+      },
+      fn: (target, { params: { user }, result: [tree, stats] }) => {
+        target.$tree(tree)
+        target.$stats(stats)
+        target.$user(user)
+        target.$grades(getTreeGrades(tree, user))
+        target.setupInitialGrade({ tree, user })
+      },
+    })
+
+    sample({
+      clock: this.setupInitialGrade,
+      fn: ({ tree, user }) => {
+        const treeGrades = Object.values(tree.treeMapping)
+          .filter((node) => node.type === 'grade')
+          .map((node) => node.attributes.grade)
+
+        return getInitialPmGrade({
+          userGrade: user.grade,
+          treeGrades,
+          lockedGrades: user.setting.practiceModeLockedGrades,
+          enrolledGrades: user.enrolledGrades,
+        })
+      },
+      target: this.setGrade,
+    })
+
+    sample({
+      clock: this.$grade,
+      source: { tree: this.$tree, stats: this.$stats, user: this.$user },
+      filter: isTreeDataReady,
+      fn: ({ tree, stats, user }, grade) => {
+        const [treeWithUserStats] = enhanceProgressMatrixData(
+          Object.values(tree.treeMapping),
+          stats,
+          [{ entityId: user._id, name: user.fullName }],
+          grade as number,
+        )
+
+        return getDomainStructure(treeWithUserStats, tree.treeMapping)
+      },
+      target: this.setDomains,
+    })
+  }
+
+  public initTreeFx = createEffect(({ user }: PmProgressGateProps) => {
+    return Promise.all([
+      this.api.getTreeFx(user.setting.practiceModeTreeId),
+      this.api.getStatisticsFx({ entityIds: [user._id] }),
+    ])
+  })
+
+  public readonly getTreeContextFx = attach({
+    source: { tree: this.$tree, stats: this.$stats, user: this.$user, grade: this.$grade },
+    mapParams: (_: void, { grade, ...source }): GetTreeContextFxParams => {
+      if (!isTreeDataReady(source, grade)) {
+        throw new Error(
+          'Cannot create treeWithUserStats in getTreeWithStatsFx - tree data is not ready.',
+        )
+      }
+      return { ...source, grade } as GetTreeContextFxParams
+    },
+    effect: createEffect(({ tree, stats, user, grade }: GetTreeContextFxParams) => {
+      const [treeWithStats] = enhanceProgressMatrixData(
+        Object.values(tree.treeMapping),
+        stats,
+        [{ entityId: user._id, name: user.fullName }],
+        grade,
+      )
+      return {
+        tree,
+        stats,
+        treeWithStats,
+      }
+    }),
+  })
+}

package/src/features/pmProgress/shared/pmProgress.constants.ts

@@ -0,0 +1,73 @@
+import { COLORS } from '@magmamath/react-native-ui'
+
+export const STATS_MAX_HEIGHT = 136
+export const RECOMMENDATIONS_LIMIT_PARAM = 150
+
+export enum CustomDomain {
+  TEACHER = 'TEACHER',
+  FLUENCY = 'FLUENCY',
+}
+
+export enum InsightsTimeframe {
+  ALL = 'all',
+  WEEK = 'week',
+  LAST_WEEK = 'lastWeek',
+}
+
+export enum SolvingFlow {
+  TEACHER = 'TEACHER',
+  MAGMA = 'MAGMA',
+  STANDARD = 'STANDARD',
+}
+
+/**
+ * Primary → _4 → _6 variants, cycling through 7 base colors.
+ * Supports up to 21 unique colors before repeating.
+ */
+export const DOMAIN_COLORS = [
+  COLORS.PRIMARY_RED,
+  COLORS.PRIMARY_MAGENTA,
+  COLORS.PRIMARY_PURPLE,
+  COLORS.PRIMARY_INDIGO,
+  COLORS.PRIMARY_TURQUOISE,
+  COLORS.PRIMARY_GREEN,
+  COLORS.PRIMARY_ORANGE,
+  COLORS.RED_4,
+  COLORS.MAGENTA_4,
+  COLORS.PURPLE_4,
+  COLORS.INDIGO_4,
+  COLORS.TURQUOISE_4,
+  COLORS.GREEN_4,
+  COLORS.ORANGE_4,
+  COLORS.RED_6,
+  COLORS.MAGENTA_6,
+  COLORS.PURPLE_6,
+  COLORS.INDIGO_6,
+  COLORS.TURQUOISE_6,
+  COLORS.GREEN_6,
+  COLORS.ORANGE_6,
+]
+
+export const DOMAIN_BORDER_COLORS = [
+  COLORS.RED_6,
+  COLORS.MAGENTA_6,
+  COLORS.PURPLE_6,
+  COLORS.INDIGO_6,
+  COLORS.TURQUOISE_6,
+  COLORS.GREEN_6,
+  COLORS.ORANGE_6,
+  COLORS.RED_6,
+  COLORS.MAGENTA_6,
+  COLORS.PURPLE_6,
+  COLORS.INDIGO_6,
+  COLORS.TURQUOISE_6,
+  COLORS.GREEN_6,
+  COLORS.ORANGE_6,
+  COLORS.RED_6,
+  COLORS.MAGENTA_6,
+  COLORS.PURPLE_6,
+  COLORS.INDIGO_6,
+  COLORS.TURQUOISE_6,
+  COLORS.GREEN_6,
+  COLORS.ORANGE_6,
+]

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

@@ -0,0 +1,239 @@
+import { COLORS } from '@magmamath/react-native-ui'
+import type { ProgressMatrixStatsDto } from '@matteappen/skills-utils/enhanceProgressData/types'
+import type {
+  Domain,
+  DomainStandard,
+  Skill,
+  SkillsCount,
+  SkillsMapping,
+  StatsResponse,
+  TreeMappingResponse,
+  User,
+} from './pmProgress.types'
+import { CustomDomain, DOMAIN_BORDER_COLORS, DOMAIN_COLORS } from './pmProgress.constants'
+import { dynamicCornerRadius, dynamicInnerRadius } from '../components/chart/chart.helpers'
+import type { PieChartManagerConfig } from '../components/chart/chart.types'
+
+function groupStandardsByDomain(
+  standardStats: ProgressMatrixStatsDto[number]['standardStats'],
+  treeMapping: TreeMappingResponse['treeMapping'],
+) {
+  const grouped = new Map<string, Domain['standards']>()
+
+  for (const [standardId, stat] of Object.entries(standardStats)) {
+    const { domainId, skillIds, skillsCount, scorePercentage, skillsToPractice } = stat
+
+    if (!grouped.has(domainId)) {
+      grouped.set(domainId, [])
+    }
+
+    grouped.get(domainId)!.push({
+      standardId,
+      title:
+        treeMapping[standardId].shortDescriptionTranslations ||
+        treeMapping[standardId].nameTranslations,
+      subtitle: treeMapping[standardId].originalId,
+      skillIds,
+      skillsToPractice,
+      skillsCount,
+      scorePercentage,
+    })
+  }
+
+  return grouped
+}
+
+function sumSkillsCount(standards: Domain['standards']): SkillsCount {
+  return standards.reduce(
+    (sum, s) => ({
+      total: sum.total + s.skillsCount.total,
+      achieved: sum.achieved + s.skillsCount.achieved,
+      failed: sum.failed + s.skillsCount.failed,
+    }),
+    { total: 0, achieved: 0, failed: 0 },
+  )
+}
+
+function averageScorePercentage(standards: Domain['standards']): number {
+  const sum = standards.reduce((acc, s) => acc + s.scorePercentage, 0)
+  return Math.round((sum / standards.length) * 10) / 10
+}
+
+export function getDomainStructure(
+  data: ProgressMatrixStatsDto[number],
+  treeMapping: TreeMappingResponse['treeMapping'],
+): Domain[] {
+  const grouped = groupStandardsByDomain(data.standardStats, treeMapping)
+
+  return Array.from(grouped.entries()).map(([domainId, standards], index) => {
+    const title = treeMapping[domainId].nameTranslations
+    const isFluency = title.toLowerCase() === CustomDomain.FLUENCY.toLowerCase()
+
+    return {
+      domainId,
+      title,
+      color: isFluency
+        ? COLORS.PRIMARY_ORANGE
+        : (DOMAIN_COLORS[index] ?? DOMAIN_COLORS[DOMAIN_COLORS.length - 1]),
+      borderColor: isFluency
+        ? COLORS.ORANGE_6
+        : (DOMAIN_BORDER_COLORS[index] ?? DOMAIN_BORDER_COLORS[DOMAIN_BORDER_COLORS.length - 1]),
+      backgroundColor: COLORS.NEUTRAL_4,
+      standards,
+      skillsCount: sumSkillsCount(standards),
+      scorePercentage: averageScorePercentage(standards),
+    }
+  })
+}
+
+type GetInitialPmGradeParams = {
+  treeGrades: number[]
+  lockedGrades: number[]
+  enrolledGrades: number[]
+  userGrade: number | null | undefined
+}
+
+/**
+ * Resolves which grade a student should practice on.
+ *
+ * When userGrade is -1, null, or undefined (i.e. not explicitly set), we fall back
+ * to the student's enrolled grades and pick the lowest one that isn't locked.
+ * If userGrade is set but locked, we find the closest unlocked grade.
+ * All candidates are filtered against lockedGrades, so only unlocked grades are ever returned.
+ *
+ * Examples:
+ *   locked=[1,2],     enrolled=[2,5], grade=4  → 4 (unlocked, use as-is)
+ *   locked=[1,2],     enrolled=[2,5], grade=-1 → 5 (lowest unlocked enrolled)
+ *   locked=[0,1,2,5], enrolled=[2,5], grade=-1 → 3 (no enrolled available, first unlocked)
+ *   locked=[0,1],     enrolled=[2,5], grade=-1 → 2 (lowest unlocked enrolled)
+ *   locked=[0,1,2,3], enrolled=[3,9], grade=-1 → 9 (lowest unlocked enrolled)
+ *   locked=[1,2,3],   enrolled=[2,5], grade=2  → 4 (grade locked, closest below=none, above=4)
+ */
+
+export function getInitialPmGrade({
+  treeGrades,
+  lockedGrades,
+  enrolledGrades,
+  userGrade,
+}: GetInitialPmGradeParams): number | null {
+  const locked = new Set(lockedGrades)
+  const unlocked = treeGrades.filter((g) => !locked.has(g)).sort((a, b) => a - b)
+
+  if (unlocked.length === 0) {
+    return null
+  }
+
+  const isUserGradeMissing = userGrade === null || userGrade === -1 || userGrade === undefined
+  if (isUserGradeMissing) {
+    const unlockedEnrolled = enrolledGrades.filter((g) => unlocked.includes(g))
+    return unlockedEnrolled.length > 0 ? Math.min(...unlockedEnrolled) : unlocked[0]
+  }
+
+  if (unlocked.includes(userGrade)) return userGrade
+
+  const nearestBelow = [...unlocked].reverse().find((grade) => grade < userGrade)
+  const nearestAbove = unlocked.find((grade) => grade > userGrade)
+  return nearestBelow ?? nearestAbove ?? unlocked[0] ?? 0
+}
+
+export function formatTime(ms: number): string {
+  const totalMinutes = Math.floor(ms / 60_000)
+  if (totalMinutes < 60) return `${totalMinutes}m`
+  const hours = Math.floor(totalMinutes / 60)
+  const minutes = totalMinutes % 60
+  return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`
+}
+
+export const isTreeDataReady = (
+  source: { tree: TreeMappingResponse | null; stats: StatsResponse | null; user: User | null },
+  grade: number | null,
+): source is { tree: TreeMappingResponse; stats: StatsResponse; user: User } =>
+  source.tree !== null && source.stats !== null && source.user !== null && grade !== null
+
+const MARGIN = 5
+export const createChartConfig = (size: number): PieChartManagerConfig => ({
+  size,
+  outerRadius: size / 2 - MARGIN,
+  innerRadius: dynamicInnerRadius,
+  gapBetweenSlices: 8,
+  cornerRadius: dynamicCornerRadius,
+  pressOffset: 4,
+  borderWidth: 4,
+  colors: {
+    background: 'white',
+    highlightedBackground: COLORS.NEUTRAL_6,
+  },
+  outerArc: {
+    color: '#FFFFFF40',
+    strokeWidth: 11.75,
+    dashWidth: 22,
+  },
+})
+
+/**
+ * Returns uncompleted skills from a single standard.
+ * Failed skills come first, then unattempted.
+ */
+export function getUncompletedSkillsFromStandard(
+  standard: DomainStandard,
+  skillsMapping: SkillsMapping,
+): Skill[] {
+  if (!standard.skillsToPractice) return []
+
+  return [...standard.skillsToPractice.failed, ...standard.skillsToPractice.unattempted]
+    .map(({ skillId }) => skillsMapping[skillId])
+    .filter(Boolean)
+    .sort((a, b) => skillsMapping[a._id]?.difficulty - skillsMapping[b._id]?.difficulty)
+}
+
+/**
+ * Returns uncompleted skills from a domain, scanning standards from the beginning.
+ * Optionally excludes a standard (used when student selected a specific one).
+ */
+export function getUncompletedSkillsFromDomain(
+  domain: Domain,
+  skillsMapping: SkillsMapping,
+  excludeStandardId?: string,
+): Skill[] {
+  const isStandardUncompleted = (standard: DomainStandard) => {
+    return standard.skillsCount.achieved < standard.skillsCount.total
+  }
+
+  return domain.standards
+    .filter((s) => isStandardUncompleted(s) && s.standardId !== excludeStandardId)
+    .flatMap((s) => getUncompletedSkillsFromStandard(s, skillsMapping))
+}
+
+/**
+ * Returns all uncompleted skills across all domains in list order.
+ * Used as a fallback when recommendation arrays are empty.
+ */
+export function getAllUncompletedSkills(
+  domains: Domain[],
+  skillsMapping: SkillsMapping,
+): Skill[] {
+  return domains
+    .filter((d) => d.skillsCount.achieved < d.skillsCount.total)
+    .flatMap((d) => getUncompletedSkillsFromDomain(d, skillsMapping))
+}
+
+/** Moves item with the given id to the front: [0,1,2,3,4] with id of 3rd → [3,0,1,2,4] */
+export function shiftToBeginningOfArray(id: string, items: Skill[]): Skill[] {
+  const index = items.findIndex((item) => item._id === id)
+  if (index <= 0) return items
+  return [items[index], ...items.slice(0, index), ...items.slice(index + 1)]
+}
+
+export function withoutDuplicates(skills: (Skill | undefined)[]): Skill[] {
+  const seen = new Set<string>()
+  return skills.filter((skill): skill is Skill => {
+    if (!skill) return false
+    if (seen.has(skill._id)) return false
+    seen.add(skill._id)
+    return true
+  })
+}
+
+export const isFluencyDomain = (title: string) => {
+  return title.toLowerCase() === CustomDomain.FLUENCY.toLowerCase()
+}