quasar 2.19.2 → 2.20.0

package/src/utils/date/date.js

@@ -1,11 +1,11 @@
 import { isDate } from '../is/is.js'
-import { pad, capitalize } from '../format/format.js'
+import { capitalize, pad } from '../format/format.js'
 import { jalaaliMonthLength } from './private.persian.js'
 import Lang, { defaultLang } from '../../plugins/lang/Lang.js'
 
-const MILLISECONDS_IN_DAY = 86400000,
-  MILLISECONDS_IN_HOUR = 3600000,
-  MILLISECONDS_IN_MINUTE = 60000,
+const MILLISECONDS_IN_DAY = 86_400_000,
+  MILLISECONDS_IN_HOUR = 3_600_000,
+  MILLISECONDS_IN_MINUTE = 60_000,
   defaultMask = 'YYYY-MM-DDTHH:mm:ss.SSSZ',
   token =
     /\[((?:[^\]\\]|\\]|\\)*)\]|do|d{1,4}|Mo|M{1,4}|m{1,2}|wo|w{1,2}|Qo|Do|DDDo|D{1,4}|YY(?:YY)?|H{1,2}|h{1,2}|s{1,2}|S{1,3}|Z{1,2}|a{1,2}|[AQExX]/g,
@@ -31,126 +31,166 @@ function getRegexData(mask, dateLocale) {
   const regexText = mask.replace(reverseToken, match => {
     index++
     switch (match) {
-      case 'YY':
+      case 'YY': {
         map.YY = index
-        return '(-?\\d{1,2})'
-      case 'YYYY':
+        return String.raw`(-?\d{1,2})`
+      }
+      case 'YYYY': {
         map.YYYY = index
-        return '(-?\\d{1,4})'
-      case 'M':
+        return String.raw`(-?\d{1,4})`
+      }
+      case 'M': {
         map.M = index
-        return '(\\d{1,2})'
-      case 'Mo':
+        return String.raw`(\d{1,2})`
+      }
+      case 'Mo': {
         map.M = index++ // bumping to M
-        return '(\\d{1,2}(st|nd|rd|th))'
-      case 'MM':
+        return String.raw`(\d{1,2}(st|nd|rd|th))`
+      }
+      case 'MM': {
         map.M = index // bumping to M
-        return '(\\d{2})'
-      case 'MMM':
+        return String.raw`(\d{2})`
+      }
+      case 'MMM': {
         map.MMM = index
         return monthsShort
-      case 'MMMM':
+      }
+      case 'MMMM': {
         map.MMMM = index
         return months
-      case 'D':
+      }
+      case 'D': {
         map.D = index
-        return '(\\d{1,2})'
-      case 'Do':
+        return String.raw`(\d{1,2})`
+      }
+      case 'Do': {
         map.D = index++ // bumping to D
-        return '(\\d{1,2}(st|nd|rd|th))'
-      case 'DD':
+        return String.raw`(\d{1,2}(st|nd|rd|th))`
+      }
+      case 'DD': {
         map.D = index // bumping to D
-        return '(\\d{2})'
-      case 'H':
+        return String.raw`(\d{2})`
+      }
+      case 'H': {
         map.H = index
-        return '(\\d{1,2})'
-      case 'HH':
+        return String.raw`(\d{1,2})`
+      }
+      case 'HH': {
         map.H = index // bumping to H
-        return '(\\d{2})'
-      case 'h':
+        return String.raw`(\d{2})`
+      }
+      case 'h': {
         map.h = index
-        return '(\\d{1,2})'
-      case 'hh':
+        return String.raw`(\d{1,2})`
+      }
+      case 'hh': {
         map.h = index // bumping to h
-        return '(\\d{2})'
-      case 'm':
+        return String.raw`(\d{2})`
+      }
+      case 'm': {
         map.m = index
-        return '(\\d{1,2})'
-      case 'mm':
+        return String.raw`(\d{1,2})`
+      }
+      case 'mm': {
         map.m = index // bumping to m
-        return '(\\d{2})'
-      case 's':
+        return String.raw`(\d{2})`
+      }
+      case 's': {
         map.s = index
-        return '(\\d{1,2})'
-      case 'ss':
+        return String.raw`(\d{1,2})`
+      }
+      case 'ss': {
         map.s = index // bumping to s
-        return '(\\d{2})'
-      case 'S':
+        return String.raw`(\d{2})`
+      }
+      case 'S': {
         map.S = index
-        return '(\\d{1})'
-      case 'SS':
+        return String.raw`(\d{1})`
+      }
+      case 'SS': {
         map.S = index // bump to S
-        return '(\\d{2})'
-      case 'SSS':
+        return String.raw`(\d{2})`
+      }
+      case 'SSS': {
         map.S = index // bump to S
-        return '(\\d{3})'
-      case 'A':
+        return String.raw`(\d{3})`
+      }
+      case 'A': {
         map.A = index
         return '(AM|PM)'
-      case 'a':
+      }
+      case 'a': {
         map.a = index
         return '(am|pm)'
-      case 'aa':
+      }
+      case 'aa': {
         map.aa = index
-        return '(a\\.m\\.|p\\.m\\.)'
+        return String.raw`(a\.m\.|p\.m\.)`
+      }
 
-      case 'ddd':
+      case 'ddd': {
         return daysShort
-      case 'dddd':
+      }
+      case 'dddd': {
         return days
+      }
       case 'Q':
       case 'd':
-      case 'E':
-        return '(\\d{1})'
-      case 'do':
+      case 'E': {
+        return String.raw`(\d{1})`
+      }
+      case 'do': {
         index++
-        return '(\\d{1}(st|nd|rd|th))'
-      case 'Qo':
+        return String.raw`(\d{1}(st|nd|rd|th))`
+      }
+      case 'Qo': {
         return '(1st|2nd|3rd|4th)'
+      }
       case 'DDD':
-      case 'DDDD':
-        return '(\\d{1,3})'
-      case 'DDDo':
+      case 'DDDD': {
+        return String.raw`(\d{1,3})`
+      }
+      case 'DDDo': {
         index++
-        return '(\\d{1,3}(st|nd|rd|th))'
-      case 'w':
-        return '(\\d{1,2})'
-      case 'wo':
+        return String.raw`(\d{1,3}(st|nd|rd|th))`
+      }
+      case 'w': {
+        return String.raw`(\d{1,2})`
+      }
+      case 'wo': {
         index++
-        return '(\\d{1,2}(st|nd|rd|th))'
-      case 'ww':
-        return '(\\d{2})'
+        return String.raw`(\d{1,2}(st|nd|rd|th))`
+      }
+      case 'ww': {
+        return String.raw`(\d{2})`
+      }
 
-      case 'Z': // to split: (?:(Z)()()|([+-])?(\\d{2}):?(\\d{2}))
+      case 'Z': {
+        // to split: (?:(Z)()()|([+-])?(\\d{2}):?(\\d{2}))
         map.Z = index
-        return '(Z|[+-]\\d{2}:\\d{2})'
-      case 'ZZ':
+        return String.raw`(Z|[+-]\d{2}:\d{2})`
+      }
+      case 'ZZ': {
         map.ZZ = index
-        return '(Z|[+-]\\d{2}\\d{2})'
+        return String.raw`(Z|[+-]\d{2}\d{2})`
+      }
 
-      case 'X':
+      case 'X': {
         map.X = index
-        return '(-?\\d+)'
-      case 'x':
+        return String.raw`(-?\d+)`
+      }
+      case 'x': {
         map.x = index
-        return '(-?\\d{4,})'
+        return String.raw`(-?\d{4,})`
+      }
 
-      default:
+      default: {
         index--
         if (match[0] === '[') {
-          match = match.substring(1, match.length - 1)
+          match = match.slice(1, -1)
         }
-        return match.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+        return match.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`)
+      }
     }
   })
 
@@ -294,7 +334,7 @@ function normalizeMod(mod) {
 
 export function adjustDate(date, rawMod, utc) {
   const mod = normalizeMod(rawMod),
-    middle = utc === true ? 'UTC' : '',
+    middle = utc ? 'UTC' : '',
     d = new Date(date),
     t =
       mod.year !== void 0 || mod.month !== void 0 || mod.date !== void 0
@@ -302,7 +342,7 @@ export function adjustDate(date, rawMod, utc) {
         : d
 
   for (const key in mod) {
-    const op = key.charAt(0).toUpperCase() + key.slice(1)
+    const op = key.at(0).toUpperCase() + key.slice(1)
     t[`set${middle}${op}`](mod[key])
   }
 
@@ -360,19 +400,13 @@ export function __splitDate(str, mask, dateLocale, calendar, defaultModel) {
   const { regex, map } = getRegexData(mask, langOpts)
 
   const match = str.match(regex)
-
-  if (match === null) {
-    return date
-  }
+  if (match === null) return date
 
   let tzString = ''
 
   if (map.X !== void 0 || map.x !== void 0) {
-    const stamp = parseInt(match[map.X !== void 0 ? map.X : map.x], 10)
-
-    if (isNaN(stamp) === true || stamp < 0) {
-      return date
-    }
+    const stamp = Number.parseInt(match[map.X ?? map.x], 10)
+    if (Number.isNaN(stamp) || stamp < 0) return date
 
     const d = new Date(stamp * (map.X !== void 0 ? 1000 : 1))
 
@@ -385,17 +419,15 @@ export function __splitDate(str, mask, dateLocale, calendar, defaultModel) {
     date.millisecond = d.getMilliseconds()
   } else {
     if (map.YYYY !== void 0) {
-      date.year = parseInt(match[map.YYYY], 10)
+      date.year = Number.parseInt(match[map.YYYY], 10)
     } else if (map.YY !== void 0) {
-      const y = parseInt(match[map.YY], 10)
+      const y = Number.parseInt(match[map.YY], 10)
       date.year = y < 0 ? y : 2000 + y
     }
 
     if (map.M !== void 0) {
-      date.month = parseInt(match[map.M], 10)
-      if (date.month < 1 || date.month > 12) {
-        return date
-      }
+      date.month = Number.parseInt(match[map.M], 10)
+      if (date.month < 1 || date.month > 12) return date
     } else if (map.MMM !== void 0) {
       date.month = monthsShort.indexOf(match[map.MMM]) + 1
     } else if (map.MMMM !== void 0) {
@@ -403,7 +435,7 @@ export function __splitDate(str, mask, dateLocale, calendar, defaultModel) {
     }
 
     if (map.D !== void 0) {
-      date.day = parseInt(match[map.D], 10)
+      date.day = Number.parseInt(match[map.D], 10)
 
       if (date.year === null || date.month === null || date.day < 1) {
         return date
@@ -414,15 +446,13 @@ export function __splitDate(str, mask, dateLocale, calendar, defaultModel) {
           ? new Date(date.year, date.month, 0).getDate()
           : jalaaliMonthLength(date.year, date.month)
 
-      if (date.day > maxDay) {
-        return date
-      }
+      if (date.day > maxDay) return date
     }
 
     if (map.H !== void 0) {
-      date.hour = parseInt(match[map.H], 10) % 24
+      date.hour = Number.parseInt(match[map.H], 10) % 24
     } else if (map.h !== void 0) {
-      date.hour = parseInt(match[map.h], 10) % 12
+      date.hour = Number.parseInt(match[map.h], 10) % 12
       if (
         (map.A && match[map.A] === 'PM') ||
         (map.a && match[map.a] === 'pm') ||
@@ -430,20 +460,21 @@ export function __splitDate(str, mask, dateLocale, calendar, defaultModel) {
       ) {
         date.hour += 12
       }
+
       date.hour = date.hour % 24
     }
 
     if (map.m !== void 0) {
-      date.minute = parseInt(match[map.m], 10) % 60
+      date.minute = Number.parseInt(match[map.m], 10) % 60
     }
 
     if (map.s !== void 0) {
-      date.second = parseInt(match[map.s], 10) % 60
+      date.second = Number.parseInt(match[map.s], 10) % 60
     }
 
     if (map.S !== void 0) {
       date.millisecond =
-        parseInt(match[map.S], 10) * 10 ** (3 - match[map.S].length)
+        Number.parseInt(match[map.S], 10) * 10 ** (3 - match[map.S].length)
     }
 
     if (map.Z !== void 0 || map.ZZ !== void 0) {
@@ -464,7 +495,7 @@ export function __splitDate(str, mask, dateLocale, calendar, defaultModel) {
 }
 
 export function isValid(date) {
-  return typeof date === 'number' ? true : isNaN(Date.parse(date)) === false
+  return Number.isFinite(date) || Number.isFinite(Date.parse(date))
 }
 
 export function buildDate(mod, utc) {
@@ -501,12 +532,12 @@ export function getWeekOfYear(date) {
 }
 
 function getDayIdentifier(date) {
-  return date.getFullYear() * 10000 + date.getMonth() * 100 + date.getDate()
+  return date.getFullYear() * 10_000 + date.getMonth() * 100 + date.getDate()
 }
 
 function getDateIdentifier(date, onlyDate /* = false */) {
   const d = new Date(date)
-  return onlyDate === true ? getDayIdentifier(d) : d.getTime()
+  return onlyDate ? getDayIdentifier(d) : d.getTime()
 }
 
 export function isBetweenDates(date, from, to, opts = {}) {
@@ -515,8 +546,8 @@ export function isBetweenDates(date, from, to, opts = {}) {
     cur = getDateIdentifier(date, opts.onlyDate)
 
   return (
-    (cur > d1 || (opts.inclusiveFrom === true && cur === d1)) &&
-    (cur < d2 || (opts.inclusiveTo === true && cur === d2))
+    (cur > d1 || (opts.inclusiveFrom && cur === d1)) &&
+    (cur < d2 || (opts.inclusiveTo && cur === d2))
   )
 }
 
@@ -529,74 +560,88 @@ export function subtractFromDate(date, mod) {
 
 export function startOfDate(date, unit, utc) {
   const t = new Date(date),
-    prefix = `set${utc === true ? 'UTC' : ''}`
+    prefix = `set${utc ? 'UTC' : ''}`
 
   switch (unit) {
     case 'year':
-    case 'years':
+    case 'years': {
       t[`${prefix}Month`](0)
-    case 'month':
-    case 'months':
+    }
+    case 'month': // oxlint-disable-line no-fallthrough
+    case 'months': {
       t[`${prefix}Date`](1)
-    case 'day':
+    }
+    case 'day': // oxlint-disable-line no-fallthrough
     case 'days':
-    case 'date':
+    case 'date': {
       t[`${prefix}Hours`](0)
-    case 'hour':
-    case 'hours':
+    }
+    case 'hour': // oxlint-disable-line no-fallthrough
+    case 'hours': {
       t[`${prefix}Minutes`](0)
-    case 'minute':
-    case 'minutes':
+    }
+    case 'minute': // oxlint-disable-line no-fallthrough
+    case 'minutes': {
       t[`${prefix}Seconds`](0)
-    case 'second':
-    case 'seconds':
+    }
+    case 'second': // oxlint-disable-line no-fallthrough
+    case 'seconds': {
       t[`${prefix}Milliseconds`](0)
+    }
   }
   return t
 }
 
 export function endOfDate(date, unit, utc) {
   const t = new Date(date),
-    prefix = `set${utc === true ? 'UTC' : ''}`
+    prefix = `set${utc ? 'UTC' : ''}`
 
   switch (unit) {
     case 'year':
-    case 'years':
+    case 'years': {
       t[`${prefix}Month`](11)
-    case 'month':
-    case 'months':
+    }
+    case 'month': // oxlint-disable-line no-fallthrough
+    case 'months': {
       t[`${prefix}Date`](daysInMonth(t))
-    case 'day':
+    }
+    case 'day': // oxlint-disable-line no-fallthrough
     case 'days':
-    case 'date':
+    case 'date': {
       t[`${prefix}Hours`](23)
-    case 'hour':
-    case 'hours':
+    }
+    case 'hour': // oxlint-disable-line no-fallthrough
+    case 'hours': {
       t[`${prefix}Minutes`](59)
-    case 'minute':
-    case 'minutes':
+    }
+    case 'minute': // oxlint-disable-line no-fallthrough
+    case 'minutes': {
       t[`${prefix}Seconds`](59)
-    case 'second':
-    case 'seconds':
+    }
+    case 'second': // oxlint-disable-line no-fallthrough
+    case 'seconds': {
       t[`${prefix}Milliseconds`](999)
+    }
   }
   return t
 }
 
-export function getMaxDate(date /* , ...args */) {
-  let t = new Date(date)
-  Array.prototype.slice.call(arguments, 1).forEach(d => {
-    t = Math.max(t, new Date(d))
-  })
-  return new Date(t)
+export function getMaxDate(date, ...args) {
+  const maxTimestamp = Math.max(
+    new Date(date).getTime(),
+    ...args.map(d => new Date(d).getTime())
+  )
+
+  return new Date(maxTimestamp)
 }
 
-export function getMinDate(date /*, ...args */) {
-  let t = new Date(date)
-  Array.prototype.slice.call(arguments, 1).forEach(d => {
-    t = Math.min(t, new Date(d))
-  })
-  return new Date(t)
+export function getMinDate(date, ...args) {
+  const minTimestamp = Math.min(
+    new Date(date).getTime(),
+    ...args.map(d => new Date(d).getTime())
+  )
+
+  return new Date(minTimestamp)
 }
 
 function getDiff(t, sub, interval) {
@@ -614,45 +659,51 @@ export function getDateDiff(date, subtract, unit = 'days') {
 
   switch (unit) {
     case 'years':
-    case 'year':
+    case 'year': {
       return t.getFullYear() - sub.getFullYear()
+    }
 
     case 'months':
-    case 'month':
+    case 'month': {
       return (
         (t.getFullYear() - sub.getFullYear()) * 12 +
         t.getMonth() -
         sub.getMonth()
       )
+    }
 
     case 'days':
     case 'day':
-    case 'date':
+    case 'date': {
       return getDiff(
         startOfDate(t, 'day'),
         startOfDate(sub, 'day'),
         MILLISECONDS_IN_DAY
       )
+    }
 
     case 'hours':
-    case 'hour':
+    case 'hour': {
       return getDiff(
         startOfDate(t, 'hour'),
         startOfDate(sub, 'hour'),
         MILLISECONDS_IN_HOUR
       )
+    }
 
     case 'minutes':
-    case 'minute':
+    case 'minute': {
       return getDiff(
         startOfDate(t, 'minute'),
         startOfDate(sub, 'minute'),
         MILLISECONDS_IN_MINUTE
       )
+    }
 
     case 'seconds':
-    case 'second':
+    case 'second': {
       return getDiff(startOfDate(t, 'second'), startOfDate(sub, 'second'), 1000)
+    }
   }
 }
 
@@ -661,11 +712,7 @@ export function getDayOfYear(date) {
 }
 
 export function inferDateFormat(date) {
-  return isDate(date) === true
-    ? 'date'
-    : typeof date === 'number'
-      ? 'number'
-      : 'string'
+  return isDate(date) ? 'date' : typeof date === 'number' ? 'number' : 'string'
 }
 
 export function getDateBetween(date, min, max) {
@@ -698,39 +745,46 @@ export function isSameDate(date, date2, unit) {
 
   switch (unit) {
     case 'second':
-    case 'seconds':
+    case 'seconds': {
       if (t.getSeconds() !== d.getSeconds()) {
         return false
       }
-    case 'minute': // intentional fall-through
-    case 'minutes':
+    }
+    case 'minute': // oxlint-disable-line no-fallthrough
+    case 'minutes': {
       if (t.getMinutes() !== d.getMinutes()) {
         return false
       }
-    case 'hour': // intentional fall-through
-    case 'hours':
+    }
+    case 'hour': // oxlint-disable-line no-fallthrough
+    case 'hours': {
       if (t.getHours() !== d.getHours()) {
         return false
       }
-    case 'day': // intentional fall-through
+    }
+    case 'day': // oxlint-disable-line no-fallthrough
     case 'days':
-    case 'date':
+    case 'date': {
       if (t.getDate() !== d.getDate()) {
         return false
       }
-    case 'month': // intentional fall-through
-    case 'months':
+    }
+    case 'month': // oxlint-disable-line no-fallthrough
+    case 'months': {
       if (t.getMonth() !== d.getMonth()) {
         return false
       }
-    case 'year': // intentional fall-through
-    case 'years':
+    }
+    case 'year': // oxlint-disable-line no-fallthrough
+    case 'years': {
       if (t.getFullYear() !== d.getFullYear()) {
         return false
       }
       break
-    default:
+    }
+    default: {
       throw new Error(`date isSameDate unknown unit ${unit}`)
+    }
   }
 
   return true
@@ -745,12 +799,15 @@ function getOrdinal(n) {
     return `${n}th`
   }
   switch (n % 10) {
-    case 1:
+    case 1: {
       return `${n}st`
-    case 2:
+    }
+    case 2: {
       return `${n}nd`
-    case 3:
+    }
+    case 3: {
       return `${n}rd`
+    }
   }
   return `${n}th`
 }
@@ -994,7 +1051,7 @@ export function formatDate(
 
   const date = new Date(val)
 
-  if (isNaN(date)) return
+  if (Number.isNaN(date)) return
 
   if (mask === void 0) {
     mask = defaultMask
@@ -1007,12 +1064,12 @@ export function formatDate(
       ? formatter[match](date, locale, __forcedYear, __forcedTimezoneOffset)
       : text === void 0
         ? match
-        : text.split('\\]').join(']')
+        : text.split(String.raw`\]`).join(']')
   )
 }
 
 export function clone(date) {
-  return isDate(date) === true ? new Date(date.getTime()) : date
+  return isDate(date) ? new Date(date) : date
 }
 
 export default {