@01-edu/shared 2.0.4 → 2.0.6

package/programming-languages.js

@@ -1,21 +0,0 @@
-// because of the nature of esbuild we have to put the import string hard coded
-export const langTypeInfo = {
-  go: { lang: 'go', load: () => import('@codemirror/lang-go') },
-  bash: { lang: 'bash', load: () => import('@fig/lezer-bash') },
-  sh: { lang: 'shell', load: () => import('@fig/lezer-bash') },
-  // The `label` is used for the UI (StatusBar) so it still shows "dart" instead of "javascript"
-  dart: {
-    label: 'dart',
-    lang: 'javascript',
-    load: () => import('@codemirror/lang-javascript'),
-  },
-  css: { lang: 'css', load: () => import('@codemirror/lang-css') },
-  html: { lang: 'html', load: () => import('@codemirror/lang-html') },
-  js: { lang: 'javascript', load: () => import('@codemirror/lang-javascript') },
-  md: { lang: 'markdown', load: () => import('@codemirror/lang-markdown') },
-  rs: { lang: 'rust', load: () => import('@codemirror/lang-rust') },
-  py: { lang: 'python', load: () => import('@codemirror/lang-python') },
-  java: { lang: 'java', load: () => import('@codemirror/lang-java') },
-  json: { lang: 'json', load: () => import('@codemirror/lang-json') },
-}
-export const supportedLang = new Set(Object.keys(langTypeInfo))

package/score.js

@@ -1,80 +0,0 @@
-const levelPoints = 5
-export const gamesScoring = {
-  memory: {
-    maxLevel: 22,
-    minRatio: 1,
-    freeAttempts: 1000,
-    maxAttempts: 1000,
-    shouldFailUnderScore: 30,
-    shouldFailUnderLevel: 7,
-    shouldSucceedFromScore: 60,
-    shouldSucceedFromLevel: 15,
-  },
-  zzle: {
-    maxLevel: 18,
-    minRatio: 1,
-    freeAttempts: 1000,
-    maxAttempts: 1000,
-    shouldFailUnderScore: 20,
-    shouldFailUnderLevel: 3,
-    shouldSucceedFromScore: 50,
-    shouldSucceedFromLevel: 10,
-  },
-}
-
-for (const game of Object.values(gamesScoring)) {
-  game.levels = [...Array(game.maxLevel + 50).keys()].map(index => ({
-    maxScore: ((index + 1) / 15 + 1) * levelPoints,
-  }))
-  game.maxScore = game.levels
-    .slice(0, game.maxLevel)
-    .reduce((acc, level) => acc + level.maxScore, 0)
-}
-
-const projectValue = (count, max, minRatio, free) => {
-  const dist = 1 - minRatio
-  const diff = max - (count - free)
-
-  if (count <= free || minRatio === 1) return 1
-  if (diff < 1) return minRatio
-  return (diff / max) * dist + minRatio
-}
-
-const getLevelRatio = (gameName, levelAttempts) => {
-  const { minRatio, freeAttempts, maxAttempts } = gamesScoring[gameName]
-
-  return projectValue(levelAttempts, maxAttempts, minRatio, freeAttempts)
-}
-
-export const getLevelScore = (gameName, levelAttempts, levelNumber) =>
-  // TODO: reduce level score differences
-  (levelNumber / 15 + 1) * levelPoints * getLevelRatio(gameName, levelAttempts)
-
-export const getLevelMaxPoints = (levelIndex, gameName) =>
-  gamesScoring[gameName].levels[levelIndex].maxScore
-
-export const getLevelsScore = (gameName, results) =>
-  results
-    .map((level, levelIndex) =>
-      getLevelScore(gameName, level.attempts, levelIndex + 1),
-    )
-    .reduce((a, b) => a + b, 0)
-
-export const getGameScores = (gameName, gamePoints, results) => {
-  const totalLevelsScore = getLevelsScore(gameName, results)
-  const ratio = totalLevelsScore / gamesScoring[gameName].maxScore
-
-  return {
-    ratio,
-    percent: ratio * 100, // TODO: represent the percentage of level done
-    points: gamePoints * ratio,
-  }
-}
-
-export const getGlobalScore = games => {
-  const totalScoreInPercent = games
-    .map(game => getGameScores(game.name, game.points, game.results).percent)
-    .reduce((a, b) => a + b, 0)
-
-  return totalScoreInPercent / games.length
-}

package/skill-definitions.js

@@ -1,359 +0,0 @@
-export const skillsSet = {
-  // technical skills
-  prog: {
-    name: 'Elementary programming',
-    description: 'Basics of computer programming',
-    type: 'technical',
-    abbreviation: 'prog-1',
-  },
-  'intermediate-prog': {
-    name: 'Intermediate programming',
-    description: 'Intermediate notions of computer programming',
-    type: 'technical',
-    abbreviation: 'prog-2',
-  },
-  'advanced-prog': {
-    name: 'Advanced programming',
-    description: 'Advanced notions of computer programming',
-    type: 'technical',
-    abbreviation: 'prog-3',
-  },
-  algo: {
-    name: 'Elementary algorithms',
-    description: 'Problem-solving, algorithm design',
-    type: 'technical',
-  },
-  'sys-admin': {
-    name: 'System administration',
-    description: 'System administration, dev ops',
-    type: 'technical',
-    abbreviation: 'devops',
-  },
-  'front-end': {
-    name: 'Front-end',
-    description: 'Front-end technologies',
-    type: 'technical',
-    abbreviation: 'front',
-  },
-  'back-end': {
-    name: 'Back-end',
-    description: 'Back-end technologies',
-    type: 'technical',
-    abbreviation: 'back',
-  },
-  stats: {
-    name: 'Statistics',
-    description: 'Data analysis, interpretation',
-    type: 'technical',
-  },
-  ai: {
-    name: 'AI',
-    description: 'Artificial intelligence, machine learning',
-    type: 'technical',
-  },
-  game: {
-    name: 'Game programming',
-    description: 'Game programming',
-    type: 'technical',
-  },
-  blockchain: {
-    name: 'Blockchain',
-    description: 'Blockchain',
-    type: 'technical',
-    abbreviation: 'BC',
-  },
-  mobile: {
-    name: 'Mobile development',
-    description: 'Mobile development',
-    type: 'technical',
-  },
-  tcp: {
-    name: 'TCP/IP',
-    description: 'TCP/IP',
-    type: 'technical',
-  },
-  cybersecurity: {
-    name: 'Cybersecurity',
-    description: 'Cybersecurity',
-    type: 'technical',
-    abbreviation: 'cyber',
-  },
-  ux: {
-    name: 'UX/UI',
-    description: 'User experience design, user interface design',
-    type: 'technical',
-  },
-  cloud: {
-    name: 'Cloud',
-    description: 'Cloud infra, deployment and scaling',
-    type: 'technical',
-  },
-  automation: {
-    name: 'Automation',
-    description:
-      'Automate tasks to reduce repetitive tasks and minimize potential errors',
-    type: 'technical',
-    abbreviation: 'autom.',
-  },
-  ci: {
-    name: 'CI/CD',
-    description:
-      'Set up CI/CD pipelines to maintain a consistent software release process',
-    type: 'technical',
-  },
-  testing: {
-    name: 'Testing',
-    description: 'TDD and other software testing strategies',
-    type: 'technical',
-    abbreviation: 'tests',
-  },
-  'curriculum-objectives-completed': {
-    name: 'Curriculum objectives completed',
-    description:
-      'Curriculum objectives completed to unlock the specialization branches',
-    type: 'technical',
-    abbreviation: 'credits',
-  },
-
-  // personal skills
-  // comm: {
-  //   name: 'Communication',
-  //   description: 'Communication, presentation, oral skills',
-  //   type: 'personal',
-  // },
-  // team: {
-  //   name: 'Team spirit',
-  //   description: 'Ability to work with people',
-  //   type: 'personal',
-  // },
-  // lead: {
-  //   name: 'Leadership',
-  //   description: 'Lead-taking, decision making',
-  //   type: 'personal',
-  // },
-  // pro: {
-  //   name: 'Professionalism',
-  //   description: 'Responsible, reliable, on time',
-  //   type: 'personal',
-  // },
-  // orga: {
-  //   name: 'Organisation',
-  //   description: 'Planning, time management',
-  //   type: 'personal',
-  // },
-  // implication: {
-  //   name: 'Implication',
-  //   description: 'Motivated, involved in projects',
-  //   type: 'personal',
-  // },
-  // initiative: {
-  //   name: 'Self initiative',
-  //   description: 'Autonomous, proactive',
-  //   type: 'personal',
-  // },
-  // crea: {
-  //   name: 'Creativity',
-  //   description: 'Curiousity, inquisitiveness',
-  //   type: 'personal',
-  // },
-  // precision: {
-  //   name: 'Precision',
-  //   description: 'Detail-oriented, clear code-writing',
-  //   type: 'personal',
-  // },
-
-  // technologies
-  go: {
-    name: 'Go',
-    type: 'technology',
-  },
-  js: {
-    name: 'JS',
-    type: 'technology',
-  },
-  rust: {
-    name: 'Rust',
-    type: 'technology',
-  },
-  java: {
-    name: 'Java',
-    type: 'technology',
-  },
-  html: {
-    name: 'HTML',
-    type: 'technology',
-  },
-  css: {
-    name: 'CSS',
-    type: 'technology',
-  },
-  unix: {
-    name: 'Unix',
-    type: 'technology',
-  },
-  docker: {
-    name: 'Docker',
-    type: 'technology',
-  },
-  sql: {
-    name: 'SQL',
-    type: 'technology',
-  },
-  'no-sql': {
-    name: 'Non-relational Databases',
-    type: 'technology',
-  },
-  c: {
-    name: 'C',
-    type: 'technology',
-  },
-  sh: {
-    name: 'Shell',
-    type: 'technology',
-  },
-  php: {
-    name: 'PHP',
-    type: 'technology',
-  },
-  python: {
-    name: 'Python',
-    type: 'technology',
-  },
-  ruby: {
-    name: 'Ruby',
-    type: 'technology',
-  },
-  'c-sharp': {
-    name: 'C#',
-    type: 'technology',
-    abbreviation: 'C#',
-  },
-  'c-pp': {
-    name: 'C++',
-    type: 'technology',
-    abbreviation: 'C++',
-  },
-  graphql: {
-    name: 'GraphQL',
-    type: 'technology',
-    abbreviation: 'GQL',
-  },
-  rails: {
-    name: 'Ruby on Rails',
-    type: 'technology',
-  },
-  laravel: {
-    name: 'Laravel',
-    type: 'technology',
-  },
-  django: {
-    name: 'Django',
-    type: 'technology',
-  },
-  react: {
-    name: 'React',
-    type: 'technology',
-  },
-  dotnet: {
-    name: '.NET',
-    type: 'technology',
-  },
-  electron: {
-    name: 'Electron',
-    type: 'technology',
-    abbreviation: 'elect.',
-  },
-  git: {
-    name: 'Git',
-    type: 'technology',
-  },
-  employability: {
-    name: 'Employability',
-    type: 'employability',
-    abbreviation: 'jobSkills',
-  },
-  'personal-development': {
-    name: 'Personal Development',
-    description:
-      'Focuses on self-awareness, self-management, communication, and core values to build a strong personal foundation for growth and autonomy.',
-    type: 'lifeskills',
-    abbreviation: 'PDev',
-  },
-  'relational-development': {
-    name: 'Relational Development',
-    description:
-      'Develops the ability to connect with others through assertiveness, empathy, and resilience, enabling healthy collaboration and conflict management.',
-    type: 'lifeskills',
-    abbreviation: 'RelDev',
-  },
-  'professional-development': {
-    name: 'Professional Development',
-    description:
-      'Strengthens strategic thinking, leadership, and professional presence to drive impact, solve complex problems, and succeed in professional environments.',
-    type: 'lifeskills',
-    abbreviation: 'ProDev',
-  },
-}
-
-export const skillTiers = [
-  { tier: 'Beginner', name: 'Code Explorer', maxValue: 25 },
-  { tier: 'Intermediate', name: 'Bug Squasher', maxValue: 50 },
-  { tier: 'Advanced', name: 'Script Wizard', maxValue: 75 },
-  { tier: 'Master', name: 'Master Hacker', maxValue: 100 },
-]
-export const skillTypes = [
-  {
-    type: 'technical',
-    name: 'Technical skills',
-    description:
-      'Technical skills are based on notions that are taught during the curriculum ; they represent what you learned from a project. They can be acquired when completing piscines, projects & exams.',
-  },
-  // {
-  //   type: 'personal',
-  //   name: 'Personal skills',
-  //   description:
-  //     'Personal skills are based on feedback given by classmates that worked with you about your personal qualities & abilities ; they represent what people observed about you.',
-  // },
-  {
-    type: 'technology',
-    name: 'Technologies',
-    description:
-      'Technologies gather the different programming languages, frameworks and platforms acquired from projects & piscines.',
-  },
-  {
-    type: 'employability',
-    name: 'Employability',
-    description:
-      'Develops professional readiness through personal branding, digital presence, and job search strategies—including portfolio building, CV writing, and effective networking.',
-  },
-  {
-    type: 'lifeskills',
-    name: 'Life Skills',
-    description:
-      'Builds essential personal, relational, and professional competencies through structured learning and practical activities, strengthening communication, collaboration, resilience, and leadership.',
-  },
-]
-
-export const hasRequiredSkills = (requiredSkills, userSkills) =>
-  Object.entries(requiredSkills || {}).every(
-    ([skillName, requiredAmount]) =>
-      (userSkills?.[skillName] || 0) >= requiredAmount,
-  )
-
-export const extractHighestSkills = (node, result = {}) => {
-  if (node?.attrs?.baseSkills) {
-    for (const [skill, value] of Object.entries(node.attrs.baseSkills)) {
-      if (!result[skill] || value > result[skill]) {
-        result[skill] = value
-      }
-    }
-  }
-
-  if (node.children) {
-    for (const child of Object.values(node.children)) {
-      extractHighestSkills(child, result) // recursively get skills rewarded by children (in the case of piscines>exercises)
-    }
-  }
-
-  return result
-}