@01-edu/shared 2.0.4 → 2.0.6

package/definitions-checker.js

@@ -1,233 +0,0 @@
-import { attributes, relationAttributes } from './attrs.js'
-import { childTypes, objectTypes } from './object-structure.ts'
-
-const normalize = str =>
-  str
-    .toLowerCase()
-    .replaceAll(/[^a-z0-9]+/g, ' ')
-    .trim()
-    .replaceAll(' ', '-')
-
-const assertDef = def => {
-  const {
-    type,
-    name,
-    attrs,
-    children: _children,
-    childrenAttrs,
-    referencePath: _referencePath,
-    ...rest
-  } = def
-  const [extra] = Object.keys(rest)
-  if (extra) {
-    throw Error(
-      `Unexpected property ${extra}, did you mean to define an attribute ?`,
-    )
-  }
-  if (type === 'campus') throw Error(`Campuses can't be defined in definitions`)
-  if (!objectTypes.has(type)) throw Error(`Invalid type property`)
-  if (!name || typeof name !== 'string') throw Error(`Invalid name property`)
-  if (!attrs || typeof attrs !== 'object' || Array.isArray(attrs)) {
-    throw Error(`Invalid attrs property`)
-  }
-  if (childrenAttrs) throw Error(`childrenAttrs is no longer supported`)
-
-  for (const key of Object.keys(attrs || {})) {
-    if (relationAttributes[key]) {
-      throw Error(
-        `Attr ${key} should be defined in the relation with its parent, not on the object itself.`,
-      )
-    }
-
-    const matches = attributes[key]
-    if (!matches) throw Error(`Undefined attr ${key}`)
-    const attrDefs = matches[type]
-    if (!attrDefs) {
-      const types = Object.keys(matches).join(', ')
-      throw Error(`${type} does not match any of ${types} for attr ${key}`)
-    }
-
-    if (attrDefs.deprecated) {
-      throw Error(`attr ${key} deprecated: ${attrDefs.deprecated}`)
-    }
-  }
-}
-
-const buildTree = (
-  { name, type, attrs, children, referencePath },
-  parent,
-  depth,
-) => {
-  // As we check for the parent / child type structure, this should never happen
-  // so we did not bother to make a more descriptive error for this case
-  if (depth > 100) throw Error('Unexpected very deep tree, maybe circular ?')
-  const object = { name, type, attrs, children: {}, referencePath, parent }
-  if (!children) return object
-  let prev
-  for (const [key, { ref, ...rest }] of Object.entries(children)) {
-    const child = buildTree(ref, object, (depth || 0) + 1)
-    child.attrs = { ...child.attrs, ...rest }
-    prev && (prev.next = child)
-    child.prev = prev
-    object.children[key] = child
-  }
-  return object
-}
-
-const assertRelation = (parent, key, relation) => {
-  if (!/^[a-z0-9-]*$/.test(key)) {
-    throw Error(
-      `Invalid key for child ${key} Kebab-case key suggestion: ${normalize(
-        key,
-      )}`,
-    )
-  }
-
-  const child = relation.ref
-  const { type } = child
-  const allowedTypes = childTypes[parent.type]
-  if (!allowedTypes.includes(type)) {
-    throw Error(`Type ${type} ${key} is not a possible child`)
-  }
-
-  // Should never happen
-  if (parent.referencePath === child.referencePath) {
-    throw Error(`Self reference in child ${key}`)
-  }
-
-  for (const key of Object.keys(relation)) {
-    if (key === 'ref') continue
-    const matches = attributes[key]
-    if (matches?.[type]?.restrictive) {
-      throw Error(
-        `Attr ${key} should be defined on the object itself, not in the relation with its parent.`,
-      )
-    }
-    const relMatches = relationAttributes[key]
-    if (!matches && !relMatches) throw Error(`Undefined attr ${key}`)
-    const attrDefs = (relMatches?.[parent.type] || matches)[type]
-    if (!attrDefs) {
-      const types = Object.keys(matches).join(', ')
-      throw Error(`${type} does not match any of ${types} for attr ${key}`)
-    }
-
-    if (attrDefs.deprecated) {
-      throw Error(`attr ${key} deprecated: ${attrDefs.deprecated}`)
-    }
-  }
-}
-
-const checkAttrs = object => {
-  for (const [key, value] of Object.entries(object.attrs)) {
-    try {
-      const attrDefs =
-        relationAttributes[key]?.[object.parent?.type]?.[object.type] ||
-        attributes[key][object.type]
-
-      if (value?.type === 'function') {
-        const fn = attrDefs.functionsByName?.[value.name]
-        if (!fn) throw Error(`function ${value.name} not found for attr ${key}`)
-      } else if (!attrDefs.check(value, object)) {
-        throw Error(`wrong type for attr ${key}`)
-      }
-    } catch (err) {
-      err.parentRef = object.parent?.referencePath
-      err.childRef = object.referencePath
-      err.value = value
-      err.key = key
-      throw err
-    }
-  }
-
-  for (const child of Object.values(object.children)) {
-    checkAttrs(child)
-  }
-}
-
-const isExam = def => def.type === 'exam'
-const assertExams = definitions => {
-  const groups = {}
-  for (const exam of definitions.filter(isExam)) {
-    let prevExamGroup = 0
-    for (const [key, exercise] of Object.entries(exam.children)) {
-      try {
-        const { group } = exercise
-        if (!group) throw Error('missing exam group')
-
-        const groupDiff = group - prevExamGroup
-        prevExamGroup = group
-        if (groupDiff > 1) throw Error('exam must not have gaps in groups')
-        if (groupDiff < 0) {
-          throw Error('exercise must be sorted by group from lower to greater')
-        }
-
-        // exam exercise group should stay consistent across all exams
-        const prevGroup = groups[key]
-        if (prevGroup == null) {
-          groups[key] = group
-        } else if (prevGroup !== group) {
-          throw Error('Exercise used in different exam groups')
-        }
-      } catch (err) {
-        err.exam = exam.referencePath
-        err.exercise = exercise.ref.referencePath
-        throw err
-      }
-    }
-  }
-}
-
-export const checkAndBuildDefinitions = async readDef => {
-  const cache = {}
-  const getDefs = async ([key, relation]) => {
-    let def
-    try {
-      const cached = cache[key]
-      def = await (cached || (cache[key] = readDef(key)))
-      relation && (relation.ref = def)
-      if (cached) return [] // skip assert and children checks if already cached
-    } catch (err) {
-      err.name = key
-      throw err
-    }
-    try {
-      assertDef(def)
-    } catch (err) {
-      err.type = def.type
-      err.referencePath = def.referencePath
-      throw err
-    }
-    const relations = Object.entries(def.children || {}).map(getDefs)
-    try {
-      return [def, ...(await Promise.all(relations)).flat()]
-    } catch (err) {
-      // Some content may be used at multiple place (ex: exam exercises)
-      // so we may have multiple parents
-      key && (err.parents || (err.parents = [])).push(key)
-      throw err
-    }
-  }
-
-  const definitions = await getDefs([])
-
-  // Assert all relations looks ok, possible child / parent, allowed attributes
-  for (const def of definitions) {
-    if (!def.children) continue
-    try {
-      for (const entry of Object.entries(def.children)) {
-        assertRelation(def, entry[0], entry[1])
-      }
-    } catch (err) {
-      err.type = def.type
-      err.referencePath = def.referencePath
-      throw err
-    }
-  }
-
-  // Check all attributes in context
-  const root = buildTree(definitions[0])
-  checkAttrs(root)
-  assertExams(definitions)
-
-  return { definitions, root }
-}

package/event-utils.js

@@ -1,58 +0,0 @@
-export const SEC = 1000
-export const MIN = 60 * SEC
-export const HOUR = 60 * MIN
-export const DAY = 24 * HOUR
-export const WEEK = 7 * DAY
-
-export const numTime = date => new Date(date).getTime()
-export const numToISOString = number =>
-  number ? new Date(number).toISOString() : Number.NaN
-export const getChildRegistrationStartAt = (parentEventStartAt, child) => {
-  const {
-    startAfter = 0,
-    eventStartDelay = 0,
-    registrationDuration,
-  } = child.attrs
-  return (
-    numTime(parentEventStartAt) +
-    (startAfter - (eventStartDelay + registrationDuration)) * MIN
-  )
-}
-export const getChildRegistrationEndAt = (parentEventStartAt, child) => {
-  const { startAfter = 0, eventStartDelay = 0 } = child.attrs
-  return numTime(parentEventStartAt) + (startAfter - eventStartDelay) * MIN
-}
-export const getChildEventStartAt = (parentEventStartAt, { attrs }) =>
-  numTime(parentEventStartAt) + (attrs.startAfter || 0) * MIN
-
-export const getChildEventEndAt = (parentEventStartAt, child) => {
-  const { startAfter = 0, eventDuration } = child.attrs
-  return numTime(parentEventStartAt) + (startAfter + eventDuration) * MIN
-}
-
-export const getChildEventInfo = (parentEventStartAt, child) => ({
-  startAt: numToISOString(
-    getChildRegistrationStartAt(parentEventStartAt, child),
-  ),
-  endAt: numToISOString(getChildRegistrationEndAt(parentEventStartAt, child)),
-  eventJoinedAt: numToISOString(
-    getChildEventStartAt(parentEventStartAt, child),
-  ),
-  eventEndAt: numToISOString(getChildEventEndAt(parentEventStartAt, child)),
-})
-
-// NB: useful when creating event for first time (add event)
-export const getEndOfEvent = ({ eventJoinedAt }, object) =>
-  numTime(eventJoinedAt) + object.attrs.eventDuration * MIN
-
-// TODO: rename this fn - also used for project
-// the best would be to find a word to label the child items that are not events
-export const getQuestStartAt = (parentEventStartAt, quest) =>
-  numTime(parentEventStartAt) + quest.attrs.delay
-export const getQuestExtraEndAt = (questStartAt, quest) => {
-  const { scopeExtraDuration, duration } = quest.attrs
-  return questStartAt + ((scopeExtraDuration || 0) + (duration || 1)) * DAY
-}
-
-// TODO: rename isPassed
-export const isFinished = date => new Date(date).getTime() < Date.now()

package/graph.js

@@ -1,96 +0,0 @@
-const isCoreObj = (contentShape, coreKey) =>
-  typeof contentShape === 'object' && Object.keys(contentShape)[0] === coreKey
-const isSatteliteObj = (contentShape, satteliteKey) =>
-  typeof contentShape === 'object' &&
-  Object.values(contentShape)[0].some(sat => sat === satteliteKey)
-
-export const getCoreSattelites = (coreObject, objectsList) => {
-  const { key, parent } = coreObject
-  const objects = objectsList || Object.values(parent.children)
-  const sattelitesSection = parent.attrs.graph.innerCircle.find(
-    s => s.type === 'slice' && s.innerArc.contents.find(c => isCoreObj(c, key)),
-  )
-  if (!sattelitesSection) return []
-  const sattelitesObject = sattelitesSection.innerArc.contents.find(c =>
-    isCoreObj(c, key),
-  )
-  const sattelitesList = new Set(...Object.values(sattelitesObject))
-
-  return objects.filter(o => sattelitesList.has(o.key))
-}
-
-export const getCoreOfSattelite = (satteliteObject, objectsList) => {
-  const { key, parent } = satteliteObject
-  const objects = objectsList || Object.values(parent.children)
-  const sattelitesSection = parent.attrs.graph?.innerCircle?.find(
-    s =>
-      s.type === 'slice' &&
-      s.innerArc?.contents.find(c => isSatteliteObj(c, key)),
-  )
-  if (!sattelitesSection) return undefined
-  const coreObject = sattelitesSection.innerArc.contents.find(c =>
-    isSatteliteObj(c, key),
-  )
-
-  return objects.filter(o => o.key === Object.keys(coreObject)[0])
-}
-
-export const flatGraphContents = graph => [
-  ...(graph.centralPoint ? [graph.centralPoint] : []),
-  ...(graph.innerCircle || []).flatMap(section =>
-    section.type === 'slice'
-      ? [
-          ...(section.entryPoint ? [section.entryPoint] : []),
-          ...(section.innerArc?.contents || []).flatMap(c =>
-            typeof c === 'string' ? c : Object.entries(c)[0].flat(),
-          ),
-          ...(section.outerArcs || []).flatMap(arc => arc.contents || []),
-        ]
-      : section.contents,
-  ),
-  ...(graph.middleCircle || []).flatMap(arc => arc.contents || []),
-  ...(graph.outerCircle || []).flatMap(arc => arc.contents || []),
-]
-
-// WARNING: without central point (for linear graph, already destructured)
-export const flatAtomeAndCoreContents = graph => [
-  ...(graph.innerCircle || []).flatMap(section =>
-    section.type === 'slice'
-      ? [
-          ...(section.entryPoint ? [section.entryPoint] : []),
-          ...(section.innerArc?.contents || []).flatMap(c =>
-            typeof c === 'string' ? c : Object.keys(c)[0],
-          ),
-          ...(section.outerArcs || []).flatMap(arc => arc.contents || []),
-        ]
-      : section.contents,
-  ),
-  ...(graph.middleCircle || []).flatMap(arc => arc.contents || []),
-  ...(graph.outerCircle || []).flatMap(arc => arc.contents || []),
-]
-
-export const limitations = {
-  LINE: {
-    maxLinesCount: 6,
-    maxContentsCount: 7, // 7 contents max split along a single line
-  },
-  SLICE: {
-    maxSlicesCount: 4,
-    innerCircle: {
-      maxSubContentsCount: 5, // 5 sub-contents max by content
-      maxContentsCount: 30, // 30 contents max spread evenly over the number of inner cirlces of slices
-    },
-    outerArc: {
-      maxArcsCount: 2,
-      maxContentsCount: 10, // 10 contents max spread evenly over the 1 or 2 outer arcs
-    },
-  },
-  MIDDLE_CIRCLE: {
-    maxArcsCount: 8,
-    maxContentsCount: 70, // 70 contents max spread evenly over the number of arcs
-  },
-  OUTER_CIRCLE: {
-    maxArcsCount: 9,
-    maxContentsCount: 90, // 90 contents max spread evenly over the number of arcs
-  },
-}

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/object-structure.ts

@@ -1,60 +0,0 @@
-export const onboardingTypes = new Set([
-  'onboarding',
-  'piscine-registration',
-  'interview',
-  'games',
-  'administration',
-  'module-registration',
-  'form-step',
-  'sign-step',
-  'upload-step',
-  'contact-validation-step',
-  'avatar-step',
-] as const)
-
-type Extract<T> = [T] extends [Set<infer V>] ? V : never
-
-export const objectTypes = new Set([
-  'module',
-  'piscine',
-  'exam',
-  'raid',
-  'quest',
-  'exercise',
-  'project',
-  'signup',
-  'campus',
-  ...onboardingTypes,
-] as const)
-
-export type ObjectType = Extract<typeof objectTypes>
-export const childTypes = {
-  campus: ['signup', 'onboarding', 'piscine', 'module'],
-  signup: [
-    'form-step',
-    'sign-step',
-    'upload-step',
-    'contact-validation-step',
-    'avatar-step',
-  ],
-  onboarding: [
-    'games',
-    'administration',
-    'interview',
-    'piscine-registration',
-    'module-registration',
-  ],
-  administration: [
-    'form-step',
-    'sign-step',
-    'upload-step',
-    'contact-validation-step',
-    'avatar-step',
-  ],
-  piscine: ['quest', 'exam', 'raid', 'project'],
-  exam: ['exercise'],
-  quest: ['exercise'],
-  module: ['project', 'piscine', 'exam'],
-} as const satisfies Partial<Record<ObjectType, ObjectType[]>>
-
-export type ChildTypes = typeof childTypes

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('/')