@01-edu/shared 1.0.0

package/README.md

@@ -0,0 +1,5 @@
+# 01-Edu shared library
+
+## `check-definitions` command
+
+

package/event-utils.js

@@ -0,0 +1,58 @@
+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/lodash.deburr.js

@@ -0,0 +1,255 @@
+/**
+ * lodash (Custom Build) <https://lodash.com/>
+ * Build: `lodash modularize exports="npm" -o ./`
+ * Copyright jQuery Foundation and other contributors <https://jquery.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+/** Used as references for various `Number` constants. */
+var INFINITY = 1 / 0;
+
+/** `Object#toString` result references. */
+var symbolTag = '[object Symbol]';
+
+/** Used to match Latin Unicode letters (excluding mathematical operators). */
+var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
+
+/** Used to compose unicode character classes. */
+var rsComboMarksRange = '\\u0300-\\u036f\\ufe20-\\ufe23',
+    rsComboSymbolsRange = '\\u20d0-\\u20f0';
+
+/** Used to compose unicode capture groups. */
+var rsCombo = '[' + rsComboMarksRange + rsComboSymbolsRange + ']';
+
+/**
+ * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and
+ * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).
+ */
+var reComboMark = RegExp(rsCombo, 'g');
+
+/** Used to map Latin Unicode letters to basic Latin letters. */
+var deburredLetters = {
+  // Latin-1 Supplement block.
+  '\xc0': 'A',  '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A',
+  '\xe0': 'a',  '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a',
+  '\xc7': 'C',  '\xe7': 'c',
+  '\xd0': 'D',  '\xf0': 'd',
+  '\xc8': 'E',  '\xc9': 'E', '\xca': 'E', '\xcb': 'E',
+  '\xe8': 'e',  '\xe9': 'e', '\xea': 'e', '\xeb': 'e',
+  '\xcc': 'I',  '\xcd': 'I', '\xce': 'I', '\xcf': 'I',
+  '\xec': 'i',  '\xed': 'i', '\xee': 'i', '\xef': 'i',
+  '\xd1': 'N',  '\xf1': 'n',
+  '\xd2': 'O',  '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O',
+  '\xf2': 'o',  '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o',
+  '\xd9': 'U',  '\xda': 'U', '\xdb': 'U', '\xdc': 'U',
+  '\xf9': 'u',  '\xfa': 'u', '\xfb': 'u', '\xfc': 'u',
+  '\xdd': 'Y',  '\xfd': 'y', '\xff': 'y',
+  '\xc6': 'Ae', '\xe6': 'ae',
+  '\xde': 'Th', '\xfe': 'th',
+  '\xdf': 'ss',
+  // Latin Extended-A block.
+  '\u0100': 'A',  '\u0102': 'A', '\u0104': 'A',
+  '\u0101': 'a',  '\u0103': 'a', '\u0105': 'a',
+  '\u0106': 'C',  '\u0108': 'C', '\u010a': 'C', '\u010c': 'C',
+  '\u0107': 'c',  '\u0109': 'c', '\u010b': 'c', '\u010d': 'c',
+  '\u010e': 'D',  '\u0110': 'D', '\u010f': 'd', '\u0111': 'd',
+  '\u0112': 'E',  '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E',
+  '\u0113': 'e',  '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e',
+  '\u011c': 'G',  '\u011e': 'G', '\u0120': 'G', '\u0122': 'G',
+  '\u011d': 'g',  '\u011f': 'g', '\u0121': 'g', '\u0123': 'g',
+  '\u0124': 'H',  '\u0126': 'H', '\u0125': 'h', '\u0127': 'h',
+  '\u0128': 'I',  '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I',
+  '\u0129': 'i',  '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i',
+  '\u0134': 'J',  '\u0135': 'j',
+  '\u0136': 'K',  '\u0137': 'k', '\u0138': 'k',
+  '\u0139': 'L',  '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L',
+  '\u013a': 'l',  '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l',
+  '\u0143': 'N',  '\u0145': 'N', '\u0147': 'N', '\u014a': 'N',
+  '\u0144': 'n',  '\u0146': 'n', '\u0148': 'n', '\u014b': 'n',
+  '\u014c': 'O',  '\u014e': 'O', '\u0150': 'O',
+  '\u014d': 'o',  '\u014f': 'o', '\u0151': 'o',
+  '\u0154': 'R',  '\u0156': 'R', '\u0158': 'R',
+  '\u0155': 'r',  '\u0157': 'r', '\u0159': 'r',
+  '\u015a': 'S',  '\u015c': 'S', '\u015e': 'S', '\u0160': 'S',
+  '\u015b': 's',  '\u015d': 's', '\u015f': 's', '\u0161': 's',
+  '\u0162': 'T',  '\u0164': 'T', '\u0166': 'T',
+  '\u0163': 't',  '\u0165': 't', '\u0167': 't',
+  '\u0168': 'U',  '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U',
+  '\u0169': 'u',  '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u',
+  '\u0174': 'W',  '\u0175': 'w',
+  '\u0176': 'Y',  '\u0177': 'y', '\u0178': 'Y',
+  '\u0179': 'Z',  '\u017b': 'Z', '\u017d': 'Z',
+  '\u017a': 'z',  '\u017c': 'z', '\u017e': 'z',
+  '\u0132': 'IJ', '\u0133': 'ij',
+  '\u0152': 'Oe', '\u0153': 'oe',
+  '\u0149': "'n", '\u017f': 'ss'
+};
+
+/** Detect free variable `global` from Node.js. */
+var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
+
+/** Detect free variable `self`. */
+var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+/** Used as a reference to the global object. */
+var root = freeGlobal || freeSelf || Function('return this')();
+
+/**
+ * The base implementation of `_.propertyOf` without support for deep paths.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Function} Returns the new accessor function.
+ */
+function basePropertyOf(object) {
+  return function(key) {
+    return object == null ? undefined : object[key];
+  };
+}
+
+/**
+ * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A
+ * letters to basic Latin letters.
+ *
+ * @private
+ * @param {string} letter The matched letter to deburr.
+ * @returns {string} Returns the deburred letter.
+ */
+var deburrLetter = basePropertyOf(deburredLetters);
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString = objectProto.toString;
+
+/** Built-in value references. */
+var Symbol = root.Symbol;
+
+/** Used to convert symbols to primitives and strings. */
+var symbolProto = Symbol ? Symbol.prototype : undefined,
+    symbolToString = symbolProto ? symbolProto.toString : undefined;
+
+/**
+ * The base implementation of `_.toString` which doesn't convert nullish
+ * values to empty strings.
+ *
+ * @private
+ * @param {*} value The value to process.
+ * @returns {string} Returns the string.
+ */
+function baseToString(value) {
+  // Exit early for strings to avoid a performance hit in some environments.
+  if (typeof value == 'string') {
+    return value;
+  }
+  if (isSymbol(value)) {
+    return symbolToString ? symbolToString.call(value) : '';
+  }
+  var result = (value + '');
+  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
+}
+
+/**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+function isObjectLike(value) {
+  return !!value && typeof value == 'object';
+}
+
+/**
+ * Checks if `value` is classified as a `Symbol` primitive or object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ *
+ * _.isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * _.isSymbol('abc');
+ * // => false
+ */
+function isSymbol(value) {
+  return typeof value == 'symbol' ||
+    (isObjectLike(value) && objectToString.call(value) == symbolTag);
+}
+
+/**
+ * Converts `value` to a string. An empty string is returned for `null`
+ * and `undefined` values. The sign of `-0` is preserved.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to process.
+ * @returns {string} Returns the string.
+ * @example
+ *
+ * _.toString(null);
+ * // => ''
+ *
+ * _.toString(-0);
+ * // => '-0'
+ *
+ * _.toString([1, 2, 3]);
+ * // => '1,2,3'
+ */
+function toString(value) {
+  return value == null ? '' : baseToString(value);
+}
+
+/**
+ * Deburrs `string` by converting
+ * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)
+ * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)
+ * letters to basic Latin letters and removing
+ * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to deburr.
+ * @returns {string} Returns the deburred string.
+ * @example
+ *
+ * _.deburr('déjà vu');
+ * // => 'deja vu'
+ */
+export function deburr(string) {
+  string = toString(string);
+  return string && string.replace(reLatin, deburrLetter).replace(reComboMark, '');
+}

package/onboarding.js

@@ -0,0 +1,38 @@
+export const onboardingTypes = new Set([
+  'onboarding',
+  'piscine-registration',
+  'interview',
+  'games',
+  'administration',
+  'module-registration',
+  'form-step',
+  'sign-step',
+  'upload-step',
+  'contact-validation-step',
+])
+
+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/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@01-edu/shared",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "files": [
+    "./event-utils.js",
+    "./onboarding.js",
+    "./path.js",
+    "./programming-languages.js",
+    "./score.js",
+    "./skill-definitions.js",
+    "./toolbox.js",
+    "./event-utils.js",
+    "./lodash.deburr.js",
+    "./onboarding.js"
+  ],
+  "license": "MIT",
+  "bin": {
+    "check-definitions": "shared/check.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/01-edu/all.git"
+  }
+}

package/path.js

@@ -0,0 +1,63 @@
+/**
+ * @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]
+}
+
+/**
+ * @returns {Object} the object in the relative path
+ * @argument relativePath {string} a relative path
+ * @argument currentObj {Object} the object from where the relative path starts
+ */
+export const getObjectFromRelativePath = (relativePath, currentObj) => {
+  const currentPath = currentObj.path
+  if (isAbsolutePath(relativePath)) {
+    throw Error("'relativePath' must be a relative path")
+  }
+  // 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
+  throw Error(
+    `Incorrect relative path '${relativePath}': no object found — current path = '${currentPath}'`,
+  )
+}
+
+const isAbsolutePath = path => path.startsWith('/')

package/programming-languages.js

@@ -0,0 +1,27 @@
+// because of the nature of esbuild we have to put the import string hard coded
+export const langTypeInfo = {
+  go: {
+    legacy: true,
+    lang: 'go',
+    load: () => import('@codemirror/legacy-modes/mode/go'),
+  },
+  sh: {
+    legacy: true,
+    lang: 'shell',
+    load: () => import('@codemirror/legacy-modes/mode/shell'),
+  },
+  dart: {
+    lang: 'dart',
+    legacy: true,
+    load: () => import('@codemirror/legacy-modes/mode/clike'),
+  },
+  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

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

@@ -0,0 +1,272 @@
+export const skillsSet = {
+  // technical skills
+  prog: {
+    name: 'Elementary programming',
+    description: 'Basics of computer programming',
+    type: 'technical',
+  },
+  algo: {
+    name: 'Elementary algorithms',
+    description: 'Problem-solving, algorithm design',
+    type: 'technical',
+  },
+  'sys-admin': {
+    name: 'System administration',
+    description: 'System administration, dev ops',
+    type: 'technical',
+  },
+  'front-end': {
+    name: 'Front-end',
+    description: 'Front-end technologies',
+    type: 'technical',
+  },
+  'back-end': {
+    name: 'Back-end',
+    description: 'Back-end technologies',
+    type: 'technical',
+  },
+  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',
+  },
+  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',
+  },
+  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',
+  },
+  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',
+  },
+  'curriculum-objectives-completed': {
+    name: 'Curriculum objectives completed',
+    description:
+      'Curriculum objectives completed to unlock the specialization branches',
+    type: 'technical',
+  },
+
+  // 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',
+  },
+  'c-pp': {
+    name: 'C++',
+    type: 'technology',
+  },
+  graphql: {
+    name: 'GraphQL',
+    type: 'technology',
+  },
+  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',
+  },
+  git: {
+    name: 'Git',
+    type: 'technology',
+  },
+}
+
+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.',
+  },
+]
+
+export const hasRequiredSkills = (requiredSkills, userSkills) =>
+  Object.entries(requiredSkills || {}).every(
+    ([skillName, requiredAmount]) =>
+      (userSkills?.[skillName] || 0) >= requiredAmount,
+  )

package/toolbox.js

@@ -0,0 +1,483 @@
+import { isFinished } from './event-utils.js'
+import { deburr } from './lodash.deburr.js'
+import { onboardingTypes } from './onboarding.js'
+
+const keyCodes = {
+  13: ({ save, value, event, allowLineBreak }) => {
+    if (event.shiftKey || allowLineBreak) return false
+    save(value)
+  }, // enter
+  27: ({ set, originalValue }) => set(originalValue), // esc
+  83: ({ save, value, event }) =>
+    event.metaKey || event.ctrlKey ? save(value) : false, // cmd+s
+}
+
+export const contentObjects = new Set([
+  'module',
+  'piscine',
+  'exam',
+  'raid',
+  'quest',
+  'exercise',
+  'project',
+  'signup',
+])
+
+export const objectTypes = new Set([...contentObjects, ...onboardingTypes])
+
+export const childTypes = {
+  campus: ['signup', 'onboarding', 'piscine', 'module'],
+  signup: ['form-step', 'sign-step', 'upload-step', 'contact-validation-step'],
+  onboarding: [
+    'games',
+    'administration',
+    'interview',
+    'piscine-registration',
+    'module-registration',
+  ],
+  administration: [
+    'form-step',
+    'sign-step',
+    'upload-step',
+    'contact-validation-step',
+  ],
+  piscine: ['quest', 'exam', 'raid', 'project'],
+  exam: ['exercise'],
+  quest: ['exercise'],
+  module: ['project', 'piscine', 'exam'],
+}
+
+export const handleKeyDownEvent = args => {
+  const handler = keyCodes[args.event.keyCode]
+
+  if (handler) {
+    if (handler(args) !== false) {
+      args.event.preventDefault()
+    }
+  }
+}
+
+export const last = array => array[array.length - 1]
+
+export const upperFirst = str =>
+  str ? str[0].toUpperCase() + str.slice(1) : ''
+
+export const replaceMap = (arr, elem, mapper) =>
+  arr.map(e => (e === elem ? mapper(e) : e))
+
+// DATE & TIME
+
+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 YEAR = 365 * DAY
+
+const unitsOfTime = Object.entries({
+  year: YEAR,
+  month: 2628000000,
+  day: DAY,
+  hour: HOUR,
+  minute: MIN,
+  second: SEC,
+})
+
+export const units = {
+  years: YEAR,
+  year: YEAR,
+  yrs: YEAR,
+  yr: YEAR,
+  y: YEAR,
+
+  weeks: WEEK,
+  week: WEEK,
+  w: WEEK,
+
+  days: DAY,
+  day: DAY,
+  d: DAY,
+
+  hours: HOUR,
+  hour: HOUR,
+  hrs: HOUR,
+  hr: HOUR,
+  h: HOUR,
+
+  minutes: MIN,
+  minute: MIN,
+  mins: MIN,
+  min: MIN,
+  m: MIN,
+
+  seconds: SEC,
+  second: SEC,
+  secs: SEC,
+  sec: SEC,
+  s: SEC,
+
+  milliseconds: 1,
+  millisecond: 1,
+  ms: 1,
+}
+
+const rtf = new Intl.RelativeTimeFormat('en', { style: 'narrow' })
+export const relativeTime = elapsed => {
+  for (const [unit, amount] of unitsOfTime) {
+    if (Math.abs(elapsed) > amount || unit === 'second') {
+      return rtf.format(Math.round(elapsed / amount), unit)
+    }
+  }
+}
+
+export const padStart0 = s => s.toString().padStart(2, '0')
+
+export const timeToMS = str => {
+  if (typeof str !== 'string') return 0
+  str = str.toLowerCase()
+  const matcher = /(?<value>[0-9.-]+) *(?<type>[a-z]+)/g
+  let match
+  let result = 0
+  while ((match = matcher.exec(str))) {
+    const { type, value } = match.groups
+    const unit = units[type]
+    const n = Number(value)
+    n && unit && (result += value * unit)
+  }
+  return Math.round(result)
+}
+
+// TODO: formated should be written formatted
+export const formatedDurationColons = (seconds, { hoursOnly } = {}) => {
+  const d = !hoursOnly && Math.floor(seconds / 86400)
+  const h = Math.floor((!hoursOnly ? seconds % 86400 : seconds) / 3600)
+  const min = Math.floor((seconds % 3600) / 60)
+  const sec = Math.floor(seconds % 60)
+  const time = `${padStart0(h)}:${padStart0(min)}:${padStart0(sec)}`
+  return d ? `${d}d ${time}` : time
+}
+
+export const formatedMS = ms => formatedDuration(Math.round(ms / SEC))
+export const timeUnits = [
+  { label: 'y', size: 31536000 },
+  { label: 'w', size: 604800 },
+  { label: 'd', size: 86400 },
+  { label: 'h', size: 3600 },
+  { label: 'm', size: 60 },
+  { label: 's', size: 1 },
+]
+export const formatedDuration = (seconds, { noSeconds } = {}) => {
+  const parts = []
+  for (const { label, size } of timeUnits) {
+    const value = Math.floor(seconds / size)
+    if (value !== 0) {
+      parts.push(`${value}${label}`)
+      seconds -= value * size
+    }
+  }
+  if (!noSeconds && seconds !== 0) {
+    parts.push(`${seconds}s`)
+  }
+  return parts.join(' ') || (noSeconds ? '0m' : '0s')
+}
+
+const toDate = date => (date instanceof Date ? date : new Date(date))
+export const toDateFormat = d => {
+  const date = toDate(d)
+  const month = (date.getMonth() + 1).toString().padStart(2, '0')
+  const day = date.getDate().toString().padStart(2, '0')
+
+  return `${date.getFullYear()}-${month}-${day}`
+}
+
+export const toISOStringWithTimeZone = d => toDate(d).toISOString().slice(0, -1)
+
+export const toDateFormatWithTime = (d, separator = 'T') => {
+  const date = toDate(d)
+  const hh = String(date.getHours()).padStart(2, '0')
+  const mm = String(date.getMinutes()).padStart(2, '0')
+
+  return `${toDateFormat(date)}${separator}${hh}:${mm}`
+}
+export const displayDateTime = dateTime => toDateFormatWithTime(dateTime, ' | ')
+
+export const getMonthName = month => monthNames[month]
+
+export const getDayName = day => weekDays[day]
+
+export const monthNames = [
+  'Jan',
+  'Feb',
+  'Mar',
+  'Apr',
+  'May',
+  'Jun',
+  'Jul',
+  'Aug',
+  'Sep',
+  'Oct',
+  'Nov',
+  'Dec',
+]
+
+const weekDays = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']
+
+const hour = hour => {
+  if (hour === 0 || hour === 12) return 12
+  return hour % 12
+}
+
+const minPad = min => String(min).padStart(2, '0')
+
+const suffix = hour => {
+  if (hour === 0) return 'am'
+  if (hour === 12) return 'pm'
+  return hour < 12 ? 'am' : 'pm'
+}
+
+export const dateIsPermanent = endAt => {
+  const date =
+    endAt instanceof Date && !Number.isNaN(endAt.valueOf())
+      ? endAt
+      : new Date(endAt)
+
+  // 32503683600000 = year 3000 timestamp
+  return date.valueOf() > 32503683600000
+}
+
+const getDateElems = date => {
+  const d = new Date(date)
+  const day = d.getDay()
+  const jj = d.getDate()
+  const mm = d.getMonth()
+  const yyyy = d.getFullYear()
+  const hh = d.getHours()
+  const min = d.getMinutes()
+  return { day, jj, mm, yyyy, hh, min }
+}
+
+export const formatedDateTime = date => {
+  if (!date) return '-'
+  if (dateIsPermanent(date)) return '∞'
+  const { jj, mm, yyyy, hh, min } = getDateElems(date)
+
+  return `${monthNames[mm]} ${jj}, ${yyyy} at ${hour(hh)}:${minPad(
+    min,
+  )} ${suffix(hh)}`
+}
+
+export const formatedDateTimeWithDay = date => {
+  if (!date) return '-'
+  if (dateIsPermanent(date)) return '∞'
+  const { day, jj, mm, yyyy, hh, min } = getDateElems(date)
+
+  return `${getDayName(day)}, ${monthNames[mm]} ${jj}, ${yyyy} at ${hour(
+    hh,
+  )}:${minPad(min)} ${suffix(hh)}`
+}
+
+export const formatedDate = date => {
+  if (!date) return '-'
+  if (dateIsPermanent(date)) return '∞'
+  return toDateFormat(date)
+}
+
+export const defer = () => {
+  const result = {}
+  result.done = new Promise((resolve, reject) => {
+    result.resolve = resolve
+    result.reject = reject
+  })
+  return result
+}
+
+// slugify('A Test') => a-test
+export const slugify = str =>
+  deburr(str)
+    .trim()
+    .toLowerCase()
+    .replace(/ /g, '-')
+    .replace(/([^a-zA-Z0-9._-]+)/, '')
+
+export const fullName = ({ firstName, lastName }) =>
+  `${firstName || ''} ${lastName || ''}`
+
+export const formatTime = t =>
+  new Date(t)
+    .toISOString()
+    .substr(11, 8)
+    .replace(/^[0:]+/, '')
+
+export const wait = delay => new Promise(resolve => setTimeout(resolve, delay))
+
+const lowertalize = str => str[0].toLowerCase() + str.slice(1)
+const upperFirstMatch = (_, firstMatch) => firstMatch.toUpperCase()
+export const toCamelCase = str =>
+  lowertalize(
+    str
+      .trim()
+      .toLowerCase()
+      .replace(/[ _-]+(.?)/g, upperFirstMatch),
+  )
+export const isNotCamel = str => /[ _-]+(.?)/g.test(str)
+
+const underscoreJoin = (_, a, b) => `${a}_${b}`
+const toSnakeCase = str =>
+  str
+    .trim()
+    .replace(/(.)([A-Z])/g, underscoreJoin)
+    .toLowerCase()
+
+// seems to match all cases:
+// 'FOO-BAR_01Chart ki' > f-o-o-b-a-r-01-chart-ki
+// phant0m-writ3r > pass
+// phoneValidation > phone-validation
+// CHart01 > c-hart01
+// addtionnal_info > addtionnal-info
+// id card > id-card
+// should be enough for unique usage we have of it in check-refs
+// checked the perfs and it is faster + more secure than using replace(s) + toLowerCase
+const toLowerCase = x => x.toLowerCase()
+export const toKebabCase = str =>
+  str
+    .match(
+      /[A-Z](?=[A-Z][a-z]+[0-9]*[a-z]|\b)|[A-Z]?[a-z]+[0-9]+[a-z]?[A-Z]*|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g,
+    )
+    .map(toLowerCase)
+    .join('-')
+
+const spaceJoin = (_, a, b) => `${a} ${b}`
+export const breath = str =>
+  str
+    .trim()
+    .replace(/(.)([A-Z])/g, spaceJoin)
+    .toLowerCase()
+export const prettyKey = key => upperFirst(breath(key))
+
+const switchKeys = (object, switchCase, switchAll) =>
+  mapEntries(object, ([key, value]) => [switchCase(key), switchAll(value)])
+
+export const toCamelKeys = object => switchKeys(object, toCamelCase, toCamelAll)
+export const toSnakeKeys = object => switchKeys(object, toSnakeCase, toSnakeAll)
+
+const switchAll = (elem, switchCase, switchKeys, toSwitchAll) => {
+  if (!elem || typeof elem !== 'object') return elem
+  return Array.isArray(elem)
+    ? elem.map(toSwitchAll)
+    : switchKeys(elem, switchCase, toSwitchAll)
+}
+
+export const toCamelAll = elem =>
+  switchAll(elem, toCamelCase, toCamelKeys, toCamelAll)
+
+export const toSnakeAll = elem =>
+  switchAll(elem, toSnakeCase, toSnakeKeys, toSnakeAll)
+
+export const arrayOf = (size, start = 0) =>
+  [...Array(size + start).keys()].slice(start)
+
+export const trimSlashEnd = path =>
+  path[path.length - 1] === '/' ? trimSlashEnd(path.slice(0, -1)) : path
+
+export const mapEntries = (obj, fn) =>
+  Object.fromEntries(Object.entries(obj).map(fn))
+
+export const mapValues = (obj, fn) =>
+  mapEntries(obj, ([k, v]) => [k, fn(v, k, obj)])
+
+export const filterEntries = (obj, fn) =>
+  Object.fromEntries(Object.entries(obj).filter(fn))
+
+export const filterValues = (obj, fn) =>
+  filterEntries(obj, ([k, v]) => [k, fn(v, k, obj)])
+
+export const getChanges = (newObject, refObject) =>
+  filterEntries(newObject, ([key, value]) => !eq(value, refObject[key]))
+
+export const hasChanged = (newObject, refObject) =>
+  Object.keys(getChanges(newObject, refObject)).length !== 0
+
+export const shuffle = arr => {
+  const newArr = [...arr]
+  let i = newArr.length
+  let j, tmp
+  while (--i > 0) {
+    j = Math.floor(Math.random() * (i + 1))
+    tmp = newArr[j]
+    newArr[j] = newArr[i]
+    newArr[i] = tmp
+  }
+  return newArr
+}
+
+// specific to data structure
+export const getChildByType = (obj, childType) =>
+  obj && Object.values(obj).find(child => child.type === childType)
+
+export const getUserName = user => {
+  if (!user) return '-'
+  if (user.attrs?.name) return user.attrs.name
+  const firstName = user.firstName || '-'
+  const lastName = user.lastName || '-'
+
+  return `${firstName} ${lastName}`
+}
+
+export const eq = (a, b) => {
+  if (a === b) return true
+  if (typeof a !== typeof b) return false
+  if (typeof a === 'number' && Number.isNaN(a) && Number.isNaN(b)) return true
+  if (typeof a === 'object') {
+    if (!a || !b) return false
+    if (a.constructor !== b.constructor) return false
+    // todo: handle regexp
+    const entries = Object.entries(a)
+    if (entries.length !== Object.values(b).length) return false
+    for (const [k, v] of entries) {
+      if (!eq(b[k], v)) return false
+    }
+    return true
+  }
+  return false
+}
+
+export const getStatus = progress => {
+  if (!progress || !progress.isDone) return
+  return progress.succeeded ? 'succeeded' : 'failed'
+}
+
+const isAccessBlocked = record =>
+  !record.type.canAccessPlatform &&
+  (new Date(record.endAt) > Date.now() ||
+    record.type.isPermanent ||
+    !record.endAt) &&
+  isFinished(record.startAt)
+
+// TODO: could maybe check user.public.canAccessPlatform?
+export const isBanned = user => {
+  const records = user?.records
+  const record = records?.find(isAccessBlocked)
+  if (!record) return
+  const err = Error('Banned')
+  err.record = record
+  return err
+}
+
+export const generateCode = () =>
+  Math.random()
+    .toString(36)
+    .slice(2, 7)
+    .padEnd(5, '#')
+    .replace(/0/gi, '_')
+    .replace(/o/gi, '-')
+    .replace(/I/gi, '?')
+    .replace(/l/gi, '$')
+
+export const base64Encode = str => {
+  const encoder = new TextEncoder()
+  const data = encoder.encode(str)
+  return btoa(String.fromCharCode.apply(null, data))
+}
+
+export const timePlusDelay = (time, delay) =>
+  new Date(new Date(time).getTime() + delay).toISOString()