@01-edu/shared 2.0.5 → 2.0.6

package/toolbox.js

@@ -1,532 +0,0 @@
-import { isFinished } from './event-utils.js'
-
-const keyCodes = {
-  13: ({ save, value, event, allowLineBreak }) => {
-    if (event.shiftKey || allowLineBreak) return false
-    return save(value)
-  }, // enter
-  27: ({ set, originalValue }) => set(originalValue), // esc
-  83: ({ save, value, event }) =>
-    event.metaKey || event.ctrlKey ? save(value) : false, // cmd+s
-}
-
-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', 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, stopFirst, useFullLabel, stopLabel } = {},
-) => {
-  const parts = []
-  if (
-    stopLabel &&
-    seconds < timeUnits.find(u => u.fullLabel === stopLabel)?.size
-  )
-    return `less than 1${useFullLabel ? ` ${stopLabel}` : timeUnits.find(u => u.fullLabel === stopLabel).label}`
-  for (const { label, size, fullLabel } of timeUnits) {
-    const value = Math.floor(seconds / size)
-    if (value !== 0) {
-      parts.push(
-        `${value}${useFullLabel ? ` ${fullLabel}` : label}${value > 1 && useFullLabel ? 's' : ''}`,
-      )
-      if (stopFirst) return parts
-      seconds -= value * size
-    }
-    if (fullLabel === stopLabel) {
-      return parts.join(' ') || (noSeconds ? '0m' : '0s')
-    }
-  }
-  if (!noSeconds && seconds !== 0) {
-    parts.push(`${seconds}s`)
-  }
-  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 '∞'
-  const date = toDate(d)
-  const month = (date.getMonth() + 1).toString().padStart(2, '0')
-  const day = date.getDate().toString().padStart(2, '0')
-
-  return isISO
-    ? `${date.getFullYear()}-${month}-${day}`
-    : `${day}/${month}/${date.getFullYear()}`
-}
-
-export const toISOStringWithTimeZone = d => toDate(d).toISOString()
-
-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 toPermanentDateFormatWithTime = (d, separator = 'T') => {
-  const date = toDate(d)
-  const hh = String(date.getHours()).padStart(2, '0')
-  const mm = String(date.getMinutes()).padStart(2, '0')
-  const month = (date.getMonth() + 1).toString().padStart(2, '0')
-  const day = date.getDate().toString().padStart(2, '0')
-
-  return `${date.getFullYear()}-${month}-${day}${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',
-]
-
-export 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, splitter = 'at') => {
-  if (!date) return '-'
-  if (dateIsPermanent(date)) return '∞'
-  const { jj, mm, yyyy, hh, min } = getDateElems(date)
-
-  return `${monthNames[mm]} ${jj}, ${yyyy} ${splitter} ${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 =>
-  str
-    .normalize('NFKD')
-    .replace(/\p{M}+/gu, '')
-    .toLowerCase()
-    .replace(/\s+/g, ' ')
-    .replace(/[^a-z0-9._ ]+/g, '')
-    .trim()
-    .replaceAll(' ', '-')
-
-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
-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(x => x.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}`
-}
-
-// This only works for JSON like value
-// no support for Dates, Regexp, Set, Map etc...
-// this is 100% fine for anything from the database
-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
-    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()
-
-export const getRecordStatus = record => {
-  if (!isFinished(record?.startAt)) return 'starting soon'
-  if (record?.endAt && isFinished(record?.endAt)) {
-    return 'finished'
-  }
-  if (record?.type.isPermanent) return 'permanent'
-  return record?.endAt ? 'in progress' : 'unblock required'
-}
-
-export const createFrequencyMap = arr =>
-  arr.reduce((map, item) => {
-    map[item] = (map[item] || 0) + 1
-    return map
-  }, {})
-
-export const postgresIntervalToMS = intervalStr => {
-  if (!intervalStr) return 0
-  // Regex to capture years, months, days, hours, minutes, seconds
-  const regex =
-    /(?:(\d+)\s+years?)?\s*(?:(\d+)\s+mons?)?\s*(?:(\d+)\s+days?)?\s*(?:(\d+):(\d+):([\d.]+))?/
-  const match = intervalStr.match(regex)
-
-  if (!match) return 0
-
-  const years = Number.parseInt(match[1] || 0, 10)
-  const months = Number.parseInt(match[2] || 0, 10)
-  const days = Number.parseInt(match[3] || 0, 10)
-  const hours = Number.parseInt(match[4] || 0, 10)
-  const minutes = Number.parseInt(match[5] || 0, 10)
-  const seconds = Number.parseFloat(match[6] || 0)
-
-  // Convert everything to milliseconds
-  const ms =
-    years * 365 * 24 * 60 * 60 * 1000 + // assume 1 year = 365 days
-    months * 30 * 24 * 60 * 60 * 1000 + // assume 1 month = 30 days
-    days * 24 * 60 * 60 * 1000 +
-    hours * 60 * 60 * 1000 +
-    minutes * 60 * 1000 +
-    seconds * 1000
-
-  return ms
-}