@01-edu/shared 2.0.5 → 2.0.6

package/hasura-model.js

@@ -1,138 +0,0 @@
-export const buildModel =
-  prepare =>
-  (name, key = 'id', type = 'Int') => {
-    const list = `${key}_list`
-    const insertQuery = prepare(`
-  mutation insert_${name} ($objects: [${name}_insert_input!]!){
-    insert_${name} (objects: $objects) { returning { ${key} } }
-  }`)
-
-    const updateQuery = prepare(`
-  mutation update_${name} ($${key}: ${type}!, $changes: ${name}_set_input!) {
-    update_${name} (where: {${key}: {_eq: $${key}}}, _set: $changes) { affected_rows }
-  }`)
-
-    const updateQueryAll = prepare(`
-  mutation update_${name} ($${list}: [${type}!], $changes: ${name}_set_input!) {
-    update_${name} (where: {${key}: {_in: $${list}}}, _set: $changes) { affected_rows }
-  }`)
-
-    const deleteQuery = prepare(`
-  mutation delete_${name} ($${key}: ${type}!) {
-    delete_${name} (where: {${key}: {_eq: $${key}}}) { affected_rows }
-  }`)
-
-    const deleteQueryAll = prepare(`
-  mutation delete_${name} ($${list}: [${type}!]) {
-    delete_${name} (where: {id: {_in: $${list}} }) { affected_rows }
-  }`)
-
-    const getCountQuery = prepare(`
-  query ${name}_count {
-    ${name}_aggregate { aggregate { count } }
-  }`)
-
-    const getKey = _ => _[key]
-    const updateOne = ({ [key]: _, ...changes }) =>
-      updateQuery({ [key]: _, changes })
-
-    const mutations = {
-      key,
-      list,
-      insertQuery,
-      deleteQuery,
-      updateQuery,
-      updateQueryAll,
-      deleteQueryAll,
-      remove: _ =>
-        Array.isArray(_)
-          ? deleteQueryAll({ [list]: _ })
-          : deleteQuery({ [key]: _ }),
-      update: (changes, _) => {
-        if (!_) return updateOne(changes)
-        return Array.isArray(_)
-          ? updateQueryAll({ changes, [list]: _ })
-          : updateQuery({ changes, [key]: _ })
-      },
-      add: async _ => {
-        const isArray = Array.isArray(_)
-        const result = await insertQuery.all({ objects: isArray ? _ : [_] })
-
-        return isArray
-          ? result[`insert_${name}`].returning.map(getKey)
-          : result[`insert_${name}`].returning[0][key]
-      },
-    }
-
-    return fields => {
-      const oneById = `($${key}: ${type}!) {
-      ${name} (where: {${key}: {_eq: $${key}}} limit: 1) {${key} ${fields}}
-    }`
-
-      const allById = `($${list}: [${type}!]) {
-      ${name} (where: {${key}: {_in: $${list}}}) {${key} ${fields}}
-    }`
-
-      const byWhere = `($where: ${name}_bool_exp!) {
-      ${name} (where: $where) {${key} ${fields}}
-    }`
-
-      const toPaginate = `(
-      $where: ${name}_bool_exp!, $orderBy: ${name}_order_by!, $limit: Int!, $offset: Int!,
-    ) {
-      ${name} ( order_by: [$orderBy] offset: $offset limit: $limit where: $where ) { ${fields} }
-    }`
-
-      const toPaginateWithCount = `(
-      $where: ${name}_bool_exp!, $orderBy: ${name}_order_by!, $limit: Int!, $offset: Int!,
-    ) {
-      ${name} ( order_by: [$orderBy] offset: $offset limit: $limit where: $where ) { ${fields} }
-      ${name}_aggregate (where: $where) { aggregate { count } } 
-    }`
-
-      const selectQuery = prepare(`query ${oneById}`)
-      const selectQueryAll = prepare(`query ${allById}`)
-      const selectQueryWhere = prepare(`query ${byWhere}`)
-      const selectQueryPaginated = prepare(
-        `query get_${name}_paginate ${toPaginate}`,
-      )
-      const selectQueryPaginatedWithCount = prepare(
-        `query get_${name}_with_count ${toPaginateWithCount}`,
-      )
-      const subscribeQuery = prepare(`subscription ${oneById}`)
-      const subscribeQueryAll = prepare(`subscription ${allById}`)
-      const subscribeQueryWhere = prepare(`subscription ${byWhere}`)
-
-      return {
-        ...mutations,
-        selectQuery,
-        selectQueryAll,
-        selectQueryWhere,
-        subscribeQuery,
-        subscribeQueryAll,
-        subscribeQueryWhere,
-        get: _ => {
-          if (Array.isArray(_)) return selectQueryAll({ [list]: _ })
-          return _ && typeof _ === 'object'
-            ? selectQueryWhere({ where: _ })
-            : selectQuery.one(_ && { [key]: _ })
-        },
-        subscribe: (sub, _) => {
-          if (Array.isArray(_)) return subscribeQueryAll(sub, { [list]: _ })
-          return _ && typeof _ === 'object'
-            ? subscribeQueryWhere(sub, { where: _ })
-            : subscribeQuery.one(sub, _ && { [key]: _ })
-        },
-        getCount: async elems => (await getCountQuery(elems)).aggregate.count,
-        getPaginated: selectQueryPaginated,
-        getPaginatedWithCount: async elems => {
-          const elemsWithCount = await selectQueryPaginatedWithCount.all(elems)
-
-          return {
-            [name]: elemsWithCount[name],
-            count: elemsWithCount[`${name}_aggregate`].aggregate.count,
-          }
-        },
-      }
-    }
-  }

package/hasura-prepare.js

@@ -1,44 +0,0 @@
-const get = _ => Object.values(_)[0]
-const getAll = _ => _
-const getOne = _ => Object.values(_)[0][0]
-export const prepare = ({ runFromString, subscribeFromString }, query) => {
-  if (typeof query !== 'string') {
-    throw Error(`Query must be a string but was ${typeof query}`)
-  }
-
-  let [_, type, name] = query.split(/^\s*(\w+)(?:\s+(\w+))?\b/)
-  if (!type) {
-    type = 'query'
-  } else if (!/^(subscription|mutation|query)$/.test(type)) {
-    throw Error(`Invalid query, type must be query, mutation or subscription`)
-  }
-  name || (name = `${type}_${query.split(/{\s*(.+?)\b/)[1]}`)
-  const payload = JSON.stringify({ query })
-  const noVars = payload
-  const base = payload.slice(0, -1)
-  const build = vars => {
-    if (!vars) return noVars
-    if (typeof vars === 'function') {
-      throw Error(
-        'variables should not be functions, verify the order of your parameters',
-      )
-    }
-    const stringified = JSON.stringify(vars)
-    if (stringified === '{}') return noVars
-    return `${base},"variables":${stringified}}`
-  }
-  const map =
-    type === 'subscription'
-      ? mapper => (sub, vars) =>
-          subscribeFromString(value => sub(mapper(value)), build(vars), name)
-      : mapper => async vars => mapper(await runFromString(build(vars), name))
-
-  const run = map(get)
-  run.all = map(getAll)
-  run.one = map(getOne)
-  run.map = map
-  run.query = query
-  return run
-}
-
-export const initPrepare = client => query => prepare(client, query)

package/languages.js

@@ -1,147 +0,0 @@
-export const languages = {
-  ab: 'Abkhazian',
-  aa: 'Afar',
-  af: 'Afrikaans',
-  sq: 'Albanian',
-  am: 'Amharic',
-  ar: 'Arabic',
-  hy: 'Armenian',
-  as: 'Assamese',
-  ay: 'Aymara',
-  az: 'Azerbaijani',
-  ba: 'Bashkir',
-  eu: 'Basque',
-  bn: 'Bengali (Bangla)',
-  dz: 'Bhutani',
-  bh: 'Bihari',
-  bi: 'Bislama',
-  br: 'Breton',
-  bg: 'Bulgarian',
-  my: 'Burmese',
-  be: 'Byelorussian (Belarusian)',
-  km: 'Cambodian',
-  ca: 'Catalan',
-  zh: 'Chinese (Simplified)',
-  // zh: 'Chinese (Traditional)',
-  co: 'Corsican',
-  hr: 'Croatian',
-  cs: 'Czech',
-  da: 'Danish',
-  nl: 'Dutch',
-  en: 'English',
-  eo: 'Esperanto',
-  et: 'Estonian',
-  fo: 'Faeroese',
-  fa: 'Farsi',
-  fj: 'Fiji',
-  fi: 'Finnish',
-  fr: 'French',
-  fy: 'Frisian',
-  gl: 'Galician',
-  gd: 'Gaelic (Scottish)',
-  gv: 'Gaelic (Manx)',
-  ka: 'Georgian',
-  de: 'German',
-  el: 'Greek',
-  kl: 'Greenlandic',
-  gn: 'Guarani',
-  gu: 'Gujarati',
-  ha: 'Hausa',
-  he: 'Hebrew',
-  hi: 'Hindi',
-  hu: 'Hungarian',
-  is: 'Icelandic',
-  id: 'Indonesian',
-  ia: 'Interlingua',
-  ie: 'Interlingue',
-  iu: 'Inuktitut',
-  ik: 'Inupiak',
-  ga: 'Irish',
-  it: 'Italian',
-  ja: 'Japanese',
-  // jv: 'Javanese',
-  kn: 'Kannada',
-  ks: 'Kashmiri',
-  kk: 'Kazakh',
-  rw: 'Kinyarwanda (Ruanda)',
-  ky: 'Kirghiz',
-  rn: 'Kirundi (Rundi)',
-  ko: 'Korean',
-  ku: 'Kurdish',
-  lo: 'Laothian',
-  la: 'Latin',
-  lv: 'Latvian (Lettish)',
-  li: 'Limburgish ( Limburger)',
-  ln: 'Lingala',
-  lt: 'Lithuanian',
-  mk: 'Macedonian',
-  mg: 'Malagasy',
-  ms: 'Malay',
-  ml: 'Malayalam',
-  mt: 'Maltese',
-  mi: 'Maori',
-  mr: 'Marathi',
-  mo: 'Moldavian',
-  mn: 'Mongolian',
-  na: 'Nauru',
-  ne: 'Nepali',
-  no: 'Norwegian',
-  oc: 'Occitan',
-  or: 'Oriya',
-  om: 'Oromo (Afan, Galla)',
-  ps: 'Pashto (Pushto)',
-  pl: 'Polish',
-  pt: 'Portuguese',
-  pa: 'Punjabi',
-  qu: 'Quechua',
-  rm: 'Rhaeto-Romance',
-  ro: 'Romanian',
-  ru: 'Russian',
-  sm: 'Samoan',
-  sg: 'Sangro',
-  sa: 'Sanskrit',
-  sr: 'Serbian',
-  sh: 'Serbo-Croatian',
-  st: 'Sesotho',
-  tn: 'Setswana',
-  sn: 'Shona',
-  sd: 'Sindhi',
-  si: 'Sinhalese',
-  ss: 'Siswati',
-  sk: 'Slovak',
-  sl: 'Slovenian',
-  so: 'Somali',
-  es: 'Spanish',
-  su: 'Sundanese',
-  sw: 'Swahili (Kiswahili)',
-  sv: 'Swedish',
-  tl: 'Tagalog',
-  tg: 'Tajik',
-  ta: 'Tamil',
-  tt: 'Tatar',
-  te: 'Telugu',
-  th: 'Thai',
-  bo: 'Tibetan',
-  ti: 'Tigrinya',
-  to: 'Tonga',
-  ts: 'Tsonga',
-  tr: 'Turkish',
-  tk: 'Turkmen',
-  tw: 'Twi',
-  ug: 'Uighur',
-  uk: 'Ukrainian',
-  ur: 'Urdu',
-  uz: 'Uzbek',
-  vi: 'Vietnamese',
-  vo: 'Volapük',
-  cy: 'Welsh',
-  wo: 'Wolof',
-  xh: 'Xhosa',
-  yi: 'Yiddish',
-  yo: 'Yoruba',
-  zu: 'Zulu',
-}
-
-export const languagesByName = Object.fromEntries(
-  Object.entries(languages).map(([code, language]) => [language, code]),
-)

package/onboarding.js

@@ -1,25 +0,0 @@
-export const prevValidated = (key, object) => {
-  const { prev } = (
-    object.parent.type !== 'onboarding' ? object : object.parent
-  ).children[key]
-  if (!prev) return true
-  return prev.attrs.status === 'succeeded'
-}
-
-export const nextStep = (key, object) => {
-  const { next } = (object.type === 'onboarding' ? object : object.parent)
-    .children[key]
-
-  return next ? next.path : undefined
-}
-
-export const getOnboardingStep = onboarding => {
-  if (!onboarding) return undefined
-  const children = Object.values(onboarding.children)
-
-  return (
-    children.find(
-      ({ attrs }) => attrs.status === 'available' || attrs.status === 'failed',
-    ) || children[children.length - 1]
-  )
-}

package/path.js

@@ -1,73 +0,0 @@
-/**
- * @returns {string} the relative path converted to absolute
- * @argument relativePath {string} a relative path
- * @argument currentPath {string} the current absolute path
- */
-export const getAbsolutePath = (relativePath, currentPath) => {
-  if (isAbsolutePath(relativePath)) {
-    throw new Error("'relativePath' must be a relative path")
-  }
-  // Ignore trailing `/` in the relative path
-  if (relativePath[relativePath.length - 1] === '/') {
-    relativePath = relativePath.slice(0, -1)
-  }
-  if (!isAbsolutePath(currentPath)) {
-    throw Error('the currentPath has to be an absolute path')
-  }
-  const absSegments = currentPath.split('/')
-  const pathSegments = relativePath.split('/')
-  for (const segment of pathSegments) {
-    if (segment === '..') {
-      if (absSegments.length > 0) {
-        absSegments.pop()
-      } else {
-        throw Error(
-          `Incorrect relative path = ${relativePath}, current path = ${currentPath}`,
-        )
-      }
-    } else if (segment !== '.') {
-      absSegments.push(segment)
-    }
-  }
-  return absSegments.join('/')
-}
-
-const walk = (object, segment) => {
-  if (!object) return
-  if (segment === '.') return object
-  return segment === '..' ? object.parent : object.children[segment]
-}
-
-/**
- * @param {string} relativePath - a relative path
- * @param {Object} currentObj - the object from where the relative path starts
- * @param {Object} [opts = { throwError: true } ] - options object with boolean property `throwError` to throw an error in case the path is invalid or no object is found
- * @returns {Object} - the object in the relative path
- */
-export const getObjectFromRelativePath = (
-  relativePath,
-  currentObj,
-  opts = { throwError: true },
-) => {
-  const currentPath = currentObj.path
-  if (isAbsolutePath(relativePath)) {
-    if (opts.throwError) throw Error("'relativePath' must be a relative path")
-    console.error("'relativePath' must be a relative path")
-    return undefined
-  }
-
-  // Ignore trailing `/` in the relative path
-  if (relativePath[relativePath.length - 1] === '/') {
-    relativePath = relativePath.slice(0, -1)
-  }
-
-  const matchingObject = relativePath.split('/').reduce(walk, currentObj)
-  if (matchingObject) return matchingObject
-
-  const errorMessage = `Incorrect relative path '${relativePath}': no object found — current path = '${currentPath}'`
-  if (opts.throwError) throw Error(errorMessage)
-  console.error(errorMessage)
-  return undefined
-}
-
-const isAbsolutePath = path => path.startsWith('/')

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/qa-utils.js

@@ -1,13 +0,0 @@
-export const stringifyJSX = value => {
-  if (!value) return ''
-  if (typeof value === 'string') return value
-  if (Array.isArray(value)) return value.map(stringifyJSX).join('')
-  return stringifyJSX(value.props?.children)
-}
-
-export const toTestId = value =>
-  stringifyJSX(value)
-    .toLowerCase()
-    .replace(/([^a-z0-9]+)/g, ' ')
-    .trim()
-    .replaceAll(' ', '-')

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
-}