@01-edu/shared 1.2.6 → 1.2.8

package/attrs-defs.js

@@ -2622,7 +2622,7 @@ types.rankDefinitionName = Literal('', {
 })
 
 types.rankDefinition = TypeObject({
-  label: 'Rank definition',
+  label: 'Rank requirements',
   type: {
     name: types.rankDefinitionName,
     level: Literal(MAX_LEVEL, {
@@ -2630,7 +2630,6 @@ types.rankDefinition = TypeObject({
       editable: true,
       required: true,
       // to put max level first in options - could also be [MAX_LEVEL, ...arrayOf(MAX_LEVEL -1, 0)]
-      options: arrayOf(MAX_LEVEL, 0).reverse(),
       check: (level, object) => {
         checkIntegerInBetween(level, 0, MAX_LEVEL)
 
@@ -2651,7 +2650,7 @@ types.rankDefinition = TypeObject({
   },
 })
 const sharedRanksDefinitions = {
-  label: 'Ranks definitions',
+  label: 'Rank requirements',
   instruction: 'List of ranks access conditions',
   editable: true,
   restrictive: true,
@@ -2668,121 +2667,11 @@ const sharedRanksDefinitions = {
   },
 }
 
-types.relatesToContent = Literal('', {
-  label: 'Content',
-  instruction:
-    'Select a child object to link this learning path status to. Each child can only be linked once.',
-  editable: true,
-  restrictive: true,
-  options: (object, value) => {
-    const learnPathStatus = object.attrs?.learnPathStatus
-      ?.flatMap(({ relatesTo }) => relatesTo)
-      .filter(v => v !== value)
-
-    const options = object.children ? Object.keys(object.children) : []
-    return !learnPathStatus
-      ? options
-      : options.filter(k => !learnPathStatus.includes(k))
-  },
-})
-
-types.relatesToArray = TypeObject({
-  label: 'Relates to',
-  instruction:
-    'Link one or more child objects to this learning path status. You can add multiple links by clicking the add button. If student did at least one he will have that status',
-  editable: true,
-  required: true,
-  restrictive: true,
-  value: (...args) => [
-    mapValues(types.relatesToArray.type, subDef =>
-      getDefaultValue(subDef, ...args),
-    ),
-  ],
-  type: [types.relatesToContent],
-})
-
-types.learnerPathStatusName = Literal('', {
-  label: 'Name',
-  editable: true,
-  required: true,
-  primary: true,
-})
-types.definitionRelatesTo = TypeObject({
-  label: 'Status Definition',
-  type: {
-    name: types.learnerPathStatusName,
-    milestone: Literal('', {
-      label: 'Hover description',
-      instruction:
-        'Text that appears when users hover over this item. Use this to provide additional context or helpful information.',
-      editable: true,
-    }),
-    relatesTo: types.relatesToArray,
-  },
-  check: (value, object) => {
-    const { relatesTo: currentRelatesTo, name } = value
-    const { learnPathStatus } = object.attrs
-    const previousValue = learnPathStatus.find(
-      ({ relatesTo }) =>
-        !(
-          currentRelatesTo.length !== relatesTo.length ||
-          currentRelatesTo.some((val, i) => val !== relatesTo[i])
-        ),
-    )
-    if (!previousValue) return
-
-    const isDifferent =
-      previousValue.relatesTo.length !== currentRelatesTo.length ||
-      previousValue.relatesTo.some((val, i) => val !== currentRelatesTo[i])
-
-    const hasSameKey = previousValue.name === name
-    if (!isDifferent && hasSameKey) return
-
-    const definitionsWithSameName = object.attrs.learnPathStatus?.find(
-      v => v.name === name,
-    )
-    if (definitionsWithSameName) {
-      throw Error(
-        `Name "${name}" is already set for a learner path status! A given name can only be attributed once.`,
-      )
-    }
-  },
-})
-
-const learnPathStatus = {
-  label: 'Learner Path Status',
-  instruction: 'List of Learner Status During Campus Steps',
-  editable: true,
-  restrictive: true,
-  value: (...args) => [
-    mapValues(types.learnPathStatus.type, subDef =>
-      getDefaultValue(subDef, ...args),
-    ),
-  ],
-  type: [types.definitionRelatesTo],
-  check: (definition, object) => {
-    if (!object.childrenRelation.length) {
-      throw Error('Must contain at least one relation')
-    }
-    if (!definition?.length || !Array.isArray(definition)) {
-      throw Error('Must be a non empty array')
-    }
-  },
-}
-
 attrs.ranksDefinitions = {
   module: sharedRanksDefinitions,
   piscine: sharedRanksDefinitions,
 }
 
-attrs.learnPathStatus = {
-  // the learn path status will define what the student is during the steps
-  // - applicant (user that registered to the platform and passed the onboarding steps, up until being accepted to participate on the selection piscine/program)
-  // - candidate (user that is participating on the selection piscine)
-  // - learner (user that succeeded on the selection piscine and is participating on the module event)
-  campus: learnPathStatus,
-}
-
 const sharedRegistrationDuration = {
   label: 'Registration duration (to an event)',
   required: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@01-edu/shared",
-  "version": "1.2.6",
+  "version": "1.2.8",
   "type": "module",
   "description": "",
   "scripts": {

package/toolbox.js

@@ -166,19 +166,25 @@ export const formatedDurationColons = (seconds, { hoursOnly } = {}) => {
 
 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 },
+  { label: 'y', fullLabel: 'year', size: 31536000 },
+  { label: 'w', fullLabel: 'week', size: 604800 },
+  { label: 'd', fullLabel: 'day', size: 86400 },
+  { label: 'h', fullLabel: 'hour', size: 3600 },
+  { label: 'm', fullLabel: 'minute', size: 60 },
+  { label: 's', fullLabel: 'second', size: 1 },
 ]
-export const formatedDuration = (seconds, { noSeconds } = {}) => {
+export const formatedDuration = (
+  seconds,
+  { noSeconds, stopFirst, useFullLabel } = {},
+) => {
   const parts = []
-  for (const { label, size } of timeUnits) {
+  for (const { label, size, fullLabel } of timeUnits) {
     const value = Math.floor(seconds / size)
     if (value !== 0) {
-      parts.push(`${value}${label}`)
+      parts.push(
+        `${value}${useFullLabel ? ` ${fullLabel}` : label}${value > 1 && useFullLabel ? 's' : ''}`,
+      )
+      if (stopFirst) return parts
       seconds -= value * size
     }
   }
@@ -188,6 +194,18 @@ export const formatedDuration = (seconds, { noSeconds } = {}) => {
   return parts.join(' ') || (noSeconds ? '0m' : '0s')
 }
 
+// Returns the difference between two dates in the following format: "3 months"
+// Always returns the largest unit only
+// If only one date is provided, it returns the difference between that date and now, the value is absolute
+export const timeDiff = (date1, date2 = Date.now()) => {
+  if (!date1) return null
+  const diffMs = toDate(date1) - toDate(date2)
+  return formatedDuration(Math.floor(Math.abs(diffMs) / 1000), {
+    stopFirst: true,
+    useFullLabel: true,
+  })
+}
+
 const toDate = date => (date instanceof Date ? date : new Date(date))
 export const toDateFormat = (d, isISO = true) => {
   if (dateIsPermanent(d)) return '∞'