@magmamath/students-features 1.2.1-rc.39 → 1.2.1-rc.4

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

@@ -1,23 +0,0 @@
-import { combine, createEvent, createStore, restore } from 'effector'
-import { UserTimeframeStats } from '../shared/pmProgress.types'
-import { PmProgressApi } from './PmProgressApi'
-import { InsightsTimeframe } from '../shared/pmProgress.constants'
-
-export class PmInsightsModel {
-  public readonly setTimeframe = createEvent<InsightsTimeframe>()
-
-  private readonly $data = createStore<UserTimeframeStats['practiceModeStatsByTimeFrame'] | null>(
-    null,
-  )
-  public readonly $timeframe = restore(this.setTimeframe, InsightsTimeframe.WEEK)
-  public readonly $insights = combine(this.$data, this.$timeframe, (stats, timeframe) => {
-    return stats ? stats[timeframe] : null
-  })
-
-  constructor(private readonly api: PmProgressApi) {
-    this.$data.on(
-      this.api.getUserInsightsFx.doneData,
-      (_, response) => response.practiceModeStatsByTimeFrame,
-    )
-  }
-}

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

@@ -1,34 +0,0 @@
-import { createEffect } from 'effector'
-import {
-  GetRecommendationsPayload,
-  RecsResponse,
-  StatsPayload,
-  StatsResponse,
-  TreeId,
-  TreeMappingResponse,
-  UserTimeframeStats,
-} from '../shared/pmProgress.types'
-
-export type PmProgressApiProps = {
-  getTree: (treeId: TreeId) => Promise<TreeMappingResponse>
-  getStatistics: (payload: StatsPayload) => Promise<StatsResponse>
-  getTeacherRecs: (payload: GetRecommendationsPayload) => Promise<RecsResponse>
-  getMagmaRecs: (payload: GetRecommendationsPayload) => Promise<RecsResponse>
-  getUserInsights: () => Promise<UserTimeframeStats>
-}
-
-export class PmProgressApi {
-  public readonly getTreeFx
-  public readonly getStatisticsFx
-  public readonly getTeacherRecsFx
-  public readonly getMagmaRecsFx
-  public readonly getUserInsightsFx
-
-  constructor(props: PmProgressApiProps) {
-    this.getTreeFx = createEffect(props.getTree)
-    this.getStatisticsFx = createEffect(props.getStatistics)
-    this.getTeacherRecsFx = createEffect(props.getTeacherRecs)
-    this.getMagmaRecsFx = createEffect(props.getMagmaRecs)
-    this.getUserInsightsFx = createEffect(() => props.getUserInsights())
-  }
-}

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

@@ -1,48 +0,0 @@
-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'
-import { PmHighlightModel } from './PmHighlightModel'
-
-type PmProgressModelProps = {
-  api: PmProgressApiProps
-}
-
-export class PmProgressModel {
-  public readonly gate = createGate<PmProgressGateProps>()
-
-  public readonly api: PmProgressApi
-  public readonly tree: PmTreeModel
-  public readonly highlight: PmHighlightModel
-  public readonly insights: PmInsightsModel
-  public readonly recommendations: PmRecommendationsModel
-  public readonly solving: PmSolvingFlowModel
-
-  constructor({ api }: PmProgressModelProps) {
-    this.api = new PmProgressApi(api)
-    this.highlight = new PmHighlightModel()
-    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,
-    })
-  }
-}

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

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

@@ -1,134 +0,0 @@
-import { createEvent, restore } from 'effector'
-import { persist } from 'effector-storage/session'
-import { SessionStorageKeys, SolvingFlow } from '../shared/pmProgress.constants'
-
-import type { PmTreeModel } from './PmTreeModel'
-import type { PmRecommendationsModel } from './PmRecommendationsModel'
-import {
-  Domain,
-  MagmaQueueData,
-  QueueBuilderData,
-  Skill,
-  StandardQueueData,
-  StartSolvingProps,
-  TeacherQueueData,
-  TreeContext,
-} from '../shared/pmProgress.types'
-import {
-  getAllUncompletedSkills,
-  getDomainStructure,
-  getUncompletedSkillsFromDomain,
-  getUncompletedSkillsFromStandard,
-  startGradesFrom,
-  shiftToBeginningOfArray,
-  withoutDuplicates,
-} from '../shared/pmProgress.helpers'
-import { enhanceProgressMatrixData } from '@matteappen/skills-utils'
-
-export class PmSolvingFlowModel {
-  public readonly reset = createEvent()
-
-  public readonly setQueue = createEvent<Skill[]>()
-  public readonly advance = createEvent()
-  public readonly setLoaderOpeningId = createEvent<string | null>()
-
-  public readonly $loaderOpeningId = restore(this.setLoaderOpeningId, null)
-
-  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,
-  ) {
-    persist({ key: SessionStorageKeys.SOLVING_QUEUE, store: this.$queue })
-  }
-
-  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 getAllGradeDomains(context: TreeContext): Domain[] {
-    const grade = this.treeModel.$grade.getState()
-    const treeGrades = this.treeModel.$grades.getState()
-
-    const grades = startGradesFrom(treeGrades, grade as number).filter(({ isLocked }) => !isLocked)
-    const treeNodes = Object.values(context.tree.treeMapping)
-
-    return grades.flatMap((grade) => {
-      const [treeWithStats] = enhanceProgressMatrixData(
-        treeNodes,
-        context.stats,
-        [{ entityId: context.user._id, name: context.user.fullName }],
-        grade.value,
-      )
-      return getDomainStructure(treeWithStats, context.tree.treeMapping)
-    })
-  }
-
-  private async getBuilder(props: StartSolvingProps): Promise<Record<SolvingFlow, () => Skill[]>> {
-    const context = await this.treeModel.getTreeContextFx()
-    const domains = this.getAllGradeDomains(context)
-    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

@@ -1,163 +0,0 @@
-import { attach, createEffect, createEvent, createStore, restore, sample } from 'effector'
-import { createAction } from 'effector-action'
-import {
-  Domain,
-  Grade,
-  PmProgressGateProps,
-  SetupInitialGradeProps,
-  StatsResponse,
-  GetTreeContextFxParams,
-  TreeContext,
-  TreeMappingResponse,
-  User,
-} from '../shared/pmProgress.types'
-import { PmProgressApi } from './PmProgressApi'
-import { enhanceProgressMatrixData } from '@matteappen/skills-utils'
-import {
-  getDomainStructure,
-  getInitialPmGrade,
-  getTreeGrades,
-  isTreeDataReady,
-} from '../shared/pmProgress.helpers'
-import { TreeNormalizer } from '../shared/TreeNormalizer'
-import { persist } from 'effector-storage/session'
-import { PmProgressStatus, SessionStorageKeys } from '../shared/pmProgress.constants'
-
-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 $isInitialized = createStore(false)
-  public readonly $grade = restore(this.setGrade, null)
-  public readonly $domains = restore(this.setDomains, [])
-  public readonly $grades = createStore<Grade[]>([])
-  public readonly $status = createStore<PmProgressStatus | null>(null)
-
-  constructor(private readonly api: PmProgressApi) {
-    persist({ key: SessionStorageKeys.GRADE, store: this.$grade })
-    persist({ key: SessionStorageKeys.DOMAINS, store: this.$domains })
-
-    this.setupFailedAndLockedStatus()
-    this.setupTreeInit()
-    this.setupGradeInit()
-    this.setupDomainStructure()
-  }
-
-  public readonly initTreeFx = createEffect(async ({ user }: PmProgressGateProps) => {
-    if (!user.setting.practiceModeTreeId) {
-      throw new Error('practiceModeTreeId is not set')
-    }
-
-    const [tree, stats] = await Promise.all([
-      this.api.getTreeFx(user.setting.practiceModeTreeId),
-      this.api.getStatisticsFx({ entityIds: [user._id] }),
-    ])
-    return [TreeNormalizer.normalize(tree), stats] as const
-  })
-
-  public readonly getTreeContextFx = attach({
-    source: { tree: this.$tree, stats: this.$stats, user: this.$user, grade: this.$grade },
-    mapParams: (_: void, source): GetTreeContextFxParams => {
-      if (!isTreeDataReady(source)) {
-        throw new Error(
-          'Cannot create treeWithUserStats in getTreeWithStatsFx - tree data is not ready.',
-        )
-      }
-      return source as GetTreeContextFxParams
-    },
-    effect: createEffect(({ tree, stats, user, grade }: GetTreeContextFxParams): TreeContext => {
-      const [treeWithStats] = enhanceProgressMatrixData(
-        Object.values(tree.treeMapping),
-        stats,
-        [{ entityId: user._id, name: user.fullName }],
-        grade,
-      )
-      return {
-        tree,
-        stats,
-        user,
-        treeWithStats,
-      }
-    }),
-  })
-
-  private setupFailedAndLockedStatus() {
-    sample({
-      clock: this.initTreeFx.fail,
-      fn: () => PmProgressStatus.ERROR,
-      target: this.$status,
-    })
-
-    sample({
-      clock: this.$grades,
-      filter: (grades) => grades.length > 0 && grades.every((g) => g.isLocked),
-      fn: () => PmProgressStatus.LOCKED,
-      target: this.$status,
-    })
-  }
-
-  private setupTreeInit() {
-    createAction(this.initTreeFx.done, {
-      target: {
-        $tree: this.$tree,
-        $stats: this.$stats,
-        $user: this.$user,
-        $grades: this.$grades,
-        $isInitialized: this.$isInitialized,
-        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 })
-        target.$isInitialized(true)
-      },
-    })
-  }
-
-  private setupGradeInit() {
-    sample({
-      clock: this.setupInitialGrade,
-      filter: () => sessionStorage.getItem(SessionStorageKeys.GRADE) === null,
-      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,
-    })
-  }
-
-  private setupDomainStructure() {
-    sample({
-      clock: [this.$grade, this.initTreeFx.doneData],
-      source: { tree: this.$tree, stats: this.$stats, user: this.$user, grade: this.$grade },
-      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,
-    })
-  }
-}

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

@@ -1,64 +0,0 @@
-import type { Skill, SkillsMapping, TreeMappingResponse } from './pmProgress.types'
-
-type TreeMapping = TreeMappingResponse['treeMapping']
-
-/**
- * Some skills from the API lack a valid ability (missing sectionId and functionName),
- * making them impossible to open in the solving flow. This normalizer strips those skills
- * and cascades the cleanup - removing standards, domains, etc. that end up empty.
- *
- * Acts as a single place to sanitize the tree API response before it enters the app.
- * Can be extended with additional normalizations as new edge cases arise.
- */
-export class TreeNormalizer {
-  static normalize(response: TreeMappingResponse): TreeMappingResponse {
-    const skillsMapping = this.getOnlyValidSkills(response.skillsMapping)
-    const validIds = new Set(Object.keys(skillsMapping))
-    const treeMapping = this.removeEmptyNodes(response.treeMapping, validIds)
-    return { ...response, skillsMapping, treeMapping }
-  }
-
-  static isSkillValid(skill: Skill) {
-    return Boolean(skill?.ability && (skill.ability.sectionId || skill.ability.functionName))
-  }
-
-  private static getOnlyValidSkills(mapping: SkillsMapping): SkillsMapping {
-    return Object.fromEntries(
-      Object.entries(mapping).filter(([, skill]) => this.isSkillValid(skill)),
-    )
-  }
-
-  private static removeEmptyNodes(treeMapping: TreeMapping, validIds: Set<string>): TreeMapping {
-    const emptyIds = this.getEmptyNodeIds(treeMapping, validIds)
-
-    return Object.fromEntries(
-      Object.entries(treeMapping)
-        .filter(([id]) => !emptyIds.has(id))
-        .map(([id, node]) => [
-          id,
-          {
-            ...node,
-            skills: node.skills.filter((sid) => validIds.has(sid)),
-            children: node.children.filter((cid) => !emptyIds.has(cid)),
-          },
-        ]),
-    )
-  }
-
-  private static getEmptyNodeIds(treeMapping: TreeMapping, validIds: Set<string>) {
-    const empty = new Set<string>()
-
-    const leafToRoot = Object.entries(treeMapping).sort(
-      ([, a], [, b]) => b.parents.length - a.parents.length,
-    )
-
-    for (const [id, node] of leafToRoot) {
-      const isEmptyLeaf = node.skills.length > 0 && node.skills.every((s) => !validIds.has(s))
-      const isEmptyParent = node.children.length > 0 && node.children.every((c) => empty.has(c))
-
-      if (isEmptyLeaf || isEmptyParent) empty.add(id)
-    }
-
-    return empty
-  }
-}

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

@@ -1,98 +0,0 @@
-import { COLORS } from '@magmamath/react-native-ui'
-
-export const STATS_MAX_HEIGHT = 136
-export const RECOMMENDATIONS_LIMIT_PARAM = 150
-export const MAX_PIE_CHART_SIZE = 505
-
-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',
-}
-
-export enum OpeningLoaderId {
-  START_BUTTON = 'START_BUTTON',
-  PRACTICE_BUTTON = 'PRACTICE_BUTTON',
-}
-
-export enum PmProgressStatus {
-  LOCKED = 'LOCKED',
-  ERROR = 'ERROR',
-}
-
-export enum SessionStorageKeys {
-  SOLVING_QUEUE = 'PM_SOLVING_QUEUE',
-  GRADE = 'PM_GRADE',
-  DOMAINS = 'PM_DOMAINS',
-}
-
-/**
- * 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 EMPTY_PIE_CHART_DATA = Array.from({ length: 5 }, () => ({
-  value: 1,
-  fillPercent: 0,
-  fillColor: COLORS.NEUTRAL_4,
-  borderColor: COLORS.NEUTRAL_4,
-  backgroundColor: COLORS.NEUTRAL_3,
-}))
-
-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,
-]