quasar 2.18.7 → 2.19.0

package/src/utils/run-sequential-promises/run-sequential-promises.js

@@ -1,4 +1,4 @@
-function parsePromises (sequentialPromises) {
+function parsePromises(sequentialPromises) {
   const isList = Array.isArray(sequentialPromises)
 
   if (isList === true) {
@@ -12,7 +12,9 @@ function parsePromises (sequentialPromises) {
 
   const resultKeys = Object.keys(sequentialPromises)
   const resultAggregator = {}
-  resultKeys.forEach(keyName => { resultAggregator[ keyName ] = null })
+  resultKeys.forEach(keyName => {
+    resultAggregator[keyName] = null
+  })
 
   return {
     isList,
@@ -55,59 +57,63 @@ function parsePromises (sequentialPromises) {
  *          An Object (when sequentialPromises param is also an Object) of the following form:
  *             { [key: string]: { key: string, status: 'fulfilled', value: any } | { key: string, status: 'rejected', reason: Error }, ... }
  */
-export default function runSequentialPromises (
+export default function runSequentialPromises(
   sequentialPromises,
   { threadsNumber = 1, abortOnFail = true } = {}
 ) {
-  let jobIndex = -1, hasAborted = false
-
-  const { isList, totalJobs, resultAggregator, resultKeys } = parsePromises(sequentialPromises)
-
-  const getPromiseThread = () => new Promise((resolve, reject) => {
-    function runNextPromise () {
-      const currentJobIndex = ++jobIndex
-
-      if (hasAborted === true || currentJobIndex >= totalJobs) {
-        resolve()
-        return
+  let jobIndex = -1,
+    hasAborted = false
+
+  const { isList, totalJobs, resultAggregator, resultKeys } =
+    parsePromises(sequentialPromises)
+
+  const getPromiseThread = () =>
+    new Promise((resolve, reject) => {
+      function runNextPromise() {
+        const currentJobIndex = ++jobIndex
+
+        if (hasAborted === true || currentJobIndex >= totalJobs) {
+          resolve()
+          return
+        }
+
+        const key =
+          isList === true ? currentJobIndex : resultKeys[currentJobIndex]
+
+        sequentialPromises[key](resultAggregator)
+          .then(value => {
+            if (hasAborted === true) {
+              resolve()
+              return // early exit
+            }
+
+            resultAggregator[key] = { key, status: 'fulfilled', value }
+
+            // timeout so it doesn't interfere with the .catch() below
+            setTimeout(runNextPromise)
+          })
+          .catch(reason => {
+            if (hasAborted === true) {
+              resolve()
+              return // early exit
+            }
+
+            const result = { key, status: 'rejected', reason }
+            resultAggregator[key] = result
+
+            if (abortOnFail === true) {
+              hasAborted = true
+              reject({ ...result, resultAggregator })
+              return // early exit
+            }
+
+            // timeout so no interference
+            setTimeout(runNextPromise)
+          })
       }
 
-      const key = isList === true ? currentJobIndex : resultKeys[ currentJobIndex ]
-
-      sequentialPromises[ key ](resultAggregator)
-        .then(value => {
-          if (hasAborted === true) {
-            resolve()
-            return // early exit
-          }
-
-          resultAggregator[ key ] = { key, status: 'fulfilled', value }
-
-          // timeout so it doesn't interfere with the .catch() below
-          setTimeout(runNextPromise)
-        })
-        .catch(reason => {
-          if (hasAborted === true) {
-            resolve()
-            return // early exit
-          }
-
-          const result = { key, status: 'rejected', reason }
-          resultAggregator[ key ] = result
-
-          if (abortOnFail === true) {
-            hasAborted = true
-            reject({ ...result, resultAggregator })
-            return // early exit
-          }
-
-          // timeout so no interference
-          setTimeout(runNextPromise)
-        })
-    }
-
-    runNextPromise()
-  })
+      runNextPromise()
+    })
 
   const threads = Array(Math.min(totalJobs, threadsNumber))
     .fill(null)

package/src/utils/scroll/prevent-scroll.js

@@ -1,9 +1,12 @@
-import { hasScrollbar, getVerticalScrollPosition, getHorizontalScrollPosition } from './scroll.js'
+import {
+  hasScrollbar,
+  getVerticalScrollPosition,
+  getHorizontalScrollPosition
+} from './scroll.js'
 import { getEventPath, listenOpts, stopAndPrevent } from '../event/event.js'
 import { client } from '../../plugins/platform/Platform.js'
 
-let
-  registered = 0,
+let registered = 0,
   scrollPositionX,
   scrollPositionY,
   maxScrollTop,
@@ -13,53 +16,51 @@ let
   href,
   closeTimer = null
 
-function onWheel (e) {
+function onWheel(e) {
   if (shouldPreventScroll(e)) {
     stopAndPrevent(e)
   }
 }
 
-function shouldPreventScroll (e) {
-  if (e.target === document.body || e.target.classList.contains('q-layout__backdrop')) {
+function shouldPreventScroll(e) {
+  if (
+    e.target === document.body ||
+    e.target.classList.contains('q-layout__backdrop')
+  ) {
     return true
   }
 
-  const
-    path = getEventPath(e),
+  const path = getEventPath(e),
     shift = e.shiftKey && !e.deltaX,
     scrollY = !shift && Math.abs(e.deltaX) <= Math.abs(e.deltaY),
     delta = shift || scrollY ? e.deltaY : e.deltaX
 
   for (let index = 0; index < path.length; index++) {
-    const el = path[ index ]
+    const el = path[index]
 
     if (hasScrollbar(el, scrollY)) {
       return scrollY
-        ? (
-            delta < 0 && el.scrollTop === 0
-              ? true
-              : delta > 0 && el.scrollTop + el.clientHeight === el.scrollHeight
-          )
-        : (
-            delta < 0 && el.scrollLeft === 0
-              ? true
-              : delta > 0 && el.scrollLeft + el.clientWidth === el.scrollWidth
-          )
+        ? delta < 0 && el.scrollTop === 0
+          ? true
+          : delta > 0 && el.scrollTop + el.clientHeight === el.scrollHeight
+        : delta < 0 && el.scrollLeft === 0
+          ? true
+          : delta > 0 && el.scrollLeft + el.clientWidth === el.scrollWidth
     }
   }
 
   return true
 }
 
-function onAppleScroll (e) {
+function onAppleScroll(e) {
   if (e.target === document) {
     // required, otherwise iOS blocks further scrolling
     // until the mobile scrollbar dissappears
-    document.scrollingElement.scrollTop = document.scrollingElement.scrollTop // eslint-disable-line
+    document.scrollingElement.scrollTop = document.scrollingElement.scrollTop // oxlint-disable-line
   }
 }
 
-function onAppleResize (evt) {
+function onAppleResize(evt) {
   if (vpPendingUpdate === true) return
 
   vpPendingUpdate = true
@@ -67,8 +68,7 @@ function onAppleResize (evt) {
   requestAnimationFrame(() => {
     vpPendingUpdate = false
 
-    const
-      { height } = evt.target,
+    const { height } = evt.target,
       { clientHeight, scrollTop } = document.scrollingElement
 
     if (maxScrollTop === void 0 || height !== window.innerHeight) {
@@ -77,14 +77,15 @@ function onAppleResize (evt) {
     }
 
     if (scrollTop > maxScrollTop) {
-      document.scrollingElement.scrollTop -= Math.ceil((scrollTop - maxScrollTop) / 8)
+      document.scrollingElement.scrollTop -= Math.ceil(
+        (scrollTop - maxScrollTop) / 8
+      )
     }
   })
 }
 
-function apply (action) {
-  const
-    body = document.body,
+function apply(action) {
+  const body = document.body,
     hasViewport = window.visualViewport !== void 0
 
   if (action === 'add') {
@@ -97,13 +98,19 @@ function apply (action) {
 
     href = window.location.href
 
-    body.style.left = `-${ scrollPositionX }px`
-    body.style.top = `-${ scrollPositionY }px`
+    body.style.left = `-${scrollPositionX}px`
+    body.style.top = `-${scrollPositionY}px`
 
-    if (overflowX !== 'hidden' && (overflowX === 'scroll' || body.scrollWidth > window.innerWidth)) {
+    if (
+      overflowX !== 'hidden' &&
+      (overflowX === 'scroll' || body.scrollWidth > window.innerWidth)
+    ) {
       body.classList.add('q-body--force-scrollbar-x')
     }
-    if (overflowY !== 'hidden' && (overflowY === 'scroll' || body.scrollHeight > window.innerHeight)) {
+    if (
+      overflowY !== 'hidden' &&
+      (overflowY === 'scroll' || body.scrollHeight > window.innerHeight)
+    ) {
       body.classList.add('q-body--force-scrollbar-y')
     }
 
@@ -113,29 +120,51 @@ function apply (action) {
     if (client.is.ios === true) {
       if (hasViewport === true) {
         window.scrollTo(0, 0)
-        window.visualViewport.addEventListener('resize', onAppleResize, listenOpts.passiveCapture)
-        window.visualViewport.addEventListener('scroll', onAppleResize, listenOpts.passiveCapture)
+        window.visualViewport.addEventListener(
+          'resize',
+          onAppleResize,
+          listenOpts.passiveCapture
+        )
+        window.visualViewport.addEventListener(
+          'scroll',
+          onAppleResize,
+          listenOpts.passiveCapture
+        )
         window.scrollTo(0, 0)
-      }
-      else {
-        window.addEventListener('scroll', onAppleScroll, listenOpts.passiveCapture)
+      } else {
+        window.addEventListener(
+          'scroll',
+          onAppleScroll,
+          listenOpts.passiveCapture
+        )
       }
     }
   }
 
   if (client.is.desktop === true && client.is.mac === true) {
     // ref. https://developers.google.com/web/updates/2017/01/scrolling-intervention
-    window[ `${ action }EventListener` ]('wheel', onWheel, listenOpts.notPassive)
+    window[`${action}EventListener`]('wheel', onWheel, listenOpts.notPassive)
   }
 
   if (action === 'remove') {
     if (client.is.ios === true) {
       if (hasViewport === true) {
-        window.visualViewport.removeEventListener('resize', onAppleResize, listenOpts.passiveCapture)
-        window.visualViewport.removeEventListener('scroll', onAppleResize, listenOpts.passiveCapture)
-      }
-      else {
-        window.removeEventListener('scroll', onAppleScroll, listenOpts.passiveCapture)
+        window.visualViewport.removeEventListener(
+          'resize',
+          onAppleResize,
+          listenOpts.passiveCapture
+        )
+        window.visualViewport.removeEventListener(
+          'scroll',
+          onAppleResize,
+          listenOpts.passiveCapture
+        )
+      } else {
+        window.removeEventListener(
+          'scroll',
+          onAppleScroll,
+          listenOpts.passiveCapture
+        )
       }
     }
 
@@ -157,7 +186,7 @@ function apply (action) {
   }
 }
 
-export default function (state) {
+export default function preventScroll(state) {
   let action = 'add'
 
   if (state === true) {
@@ -170,8 +199,7 @@ export default function (state) {
     }
 
     if (registered > 1) return
-  }
-  else {
+  } else {
     if (registered === 0) return
 
     registered--
@@ -181,7 +209,7 @@ export default function (state) {
     action = 'remove'
 
     if (client.is.ios === true && client.is.nativeMobile === true) {
-      closeTimer !== null && clearTimeout(closeTimer)
+      if (closeTimer !== null) clearTimeout(closeTimer)
       closeTimer = setTimeout(() => {
         apply(action)
         closeTimer = null

package/src/utils/scroll/scroll.js

@@ -2,13 +2,19 @@ import { css, getElement } from '../dom/dom.js'
 
 export const scrollTargetProp = __QUASAR_SSR_SERVER__
   ? {} /* SSR does not know about Element */
-  : [ Element, String ]
+  : [Element, String]
 
 const scrollTargets = __QUASAR_SSR_SERVER__
   ? []
-  : [ null, document, document.body, document.scrollingElement, document.documentElement ]
-
-export function getScrollTarget (el, targetEl) {
+  : [
+      null,
+      document,
+      document.body,
+      document.scrollingElement,
+      document.documentElement
+    ]
+
+export function getScrollTarget(el, targetEl) {
   let target = getElement(targetEl)
 
   if (target === void 0) {
@@ -19,33 +25,31 @@ export function getScrollTarget (el, targetEl) {
     target = el.closest('.scroll,.scroll-y,.overflow-auto')
   }
 
-  return scrollTargets.includes(target)
-    ? window
-    : target
+  return scrollTargets.includes(target) ? window : target
 }
 
-export function getScrollHeight (el) {
+export function getScrollHeight(el) {
   return (el === window ? document.body : el).scrollHeight
 }
 
-export function getScrollWidth (el) {
+export function getScrollWidth(el) {
   return (el === window ? document.body : el).scrollWidth
 }
 
-export function getVerticalScrollPosition (scrollTarget) {
+export function getVerticalScrollPosition(scrollTarget) {
   return scrollTarget === window
     ? window.pageYOffset || window.scrollY || document.body.scrollTop || 0
     : scrollTarget.scrollTop
 }
 
-export function getHorizontalScrollPosition (scrollTarget) {
+export function getHorizontalScrollPosition(scrollTarget) {
   return scrollTarget === window
     ? window.pageXOffset || window.scrollX || document.body.scrollLeft || 0
     : scrollTarget.scrollLeft
 }
 
-export function animVerticalScrollTo (el, to, duration = 0 /* , prevTime */) {
-  const prevTime = arguments[ 3 ] === void 0 ? performance.now() : arguments[ 3 ]
+export function animVerticalScrollTo(el, to, duration = 0 /* , prevTime */) {
+  const prevTime = arguments[3] === void 0 ? performance.now() : arguments[3]
   const pos = getVerticalScrollPosition(el)
 
   if (duration <= 0) {
@@ -57,7 +61,8 @@ export function animVerticalScrollTo (el, to, duration = 0 /* , prevTime */) {
 
   requestAnimationFrame(nowTime => {
     const frameTime = nowTime - prevTime
-    const newPos = pos + (to - pos) / Math.max(frameTime, duration) * frameTime
+    const newPos =
+      pos + ((to - pos) / Math.max(frameTime, duration)) * frameTime
     setScroll(el, newPos)
     if (newPos !== to) {
       animVerticalScrollTo(el, to, duration - frameTime, nowTime)
@@ -65,8 +70,8 @@ export function animVerticalScrollTo (el, to, duration = 0 /* , prevTime */) {
   })
 }
 
-export function animHorizontalScrollTo (el, to, duration = 0 /* , prevTime */) {
-  const prevTime = arguments[ 3 ] === void 0 ? performance.now() : arguments[ 3 ]
+export function animHorizontalScrollTo(el, to, duration = 0 /* , prevTime */) {
+  const prevTime = arguments[3] === void 0 ? performance.now() : arguments[3]
   const pos = getHorizontalScrollPosition(el)
 
   if (duration <= 0) {
@@ -78,7 +83,8 @@ export function animHorizontalScrollTo (el, to, duration = 0 /* , prevTime */) {
 
   requestAnimationFrame(nowTime => {
     const frameTime = nowTime - prevTime
-    const newPos = pos + (to - pos) / Math.max(frameTime, duration) * frameTime
+    const newPos =
+      pos + ((to - pos) / Math.max(frameTime, duration)) * frameTime
     setHorizontalScroll(el, newPos)
     if (newPos !== to) {
       animHorizontalScrollTo(el, to, duration - frameTime, nowTime)
@@ -86,23 +92,29 @@ export function animHorizontalScrollTo (el, to, duration = 0 /* , prevTime */) {
   })
 }
 
-function setScroll (scrollTarget, offset) {
+function setScroll(scrollTarget, offset) {
   if (scrollTarget === window) {
-    window.scrollTo(window.pageXOffset || window.scrollX || document.body.scrollLeft || 0, offset)
+    window.scrollTo(
+      window.pageXOffset || window.scrollX || document.body.scrollLeft || 0,
+      offset
+    )
     return
   }
   scrollTarget.scrollTop = offset
 }
 
-function setHorizontalScroll (scrollTarget, offset) {
+function setHorizontalScroll(scrollTarget, offset) {
   if (scrollTarget === window) {
-    window.scrollTo(offset, window.pageYOffset || window.scrollY || document.body.scrollTop || 0)
+    window.scrollTo(
+      offset,
+      window.pageYOffset || window.scrollY || document.body.scrollTop || 0
+    )
     return
   }
   scrollTarget.scrollLeft = offset
 }
 
-export function setVerticalScrollPosition (scrollTarget, offset, duration) {
+export function setVerticalScrollPosition(scrollTarget, offset, duration) {
   if (duration) {
     animVerticalScrollTo(scrollTarget, offset, duration)
     return
@@ -110,7 +122,7 @@ export function setVerticalScrollPosition (scrollTarget, offset, duration) {
   setScroll(scrollTarget, offset)
 }
 
-export function setHorizontalScrollPosition (scrollTarget, offset, duration) {
+export function setHorizontalScrollPosition(scrollTarget, offset, duration) {
   if (duration) {
     animHorizontalScrollTo(scrollTarget, offset, duration)
     return
@@ -119,13 +131,10 @@ export function setHorizontalScrollPosition (scrollTarget, offset, duration) {
 }
 
 let size
-export function getScrollbarWidth () {
-  if (size !== undefined) {
-    return size
-  }
+export function getScrollbarWidth() {
+  if (size !== void 0) return size
 
-  const
-    inner = document.createElement('p'),
+  const inner = document.createElement('p'),
     outer = document.createElement('div')
 
   css(inner, {
@@ -160,26 +169,24 @@ export function getScrollbarWidth () {
   return size
 }
 
-export function hasScrollbar (el, onY = true) {
+export function hasScrollbar(el, onY = true) {
   if (!el || el.nodeType !== Node.ELEMENT_NODE) {
     return false
   }
 
   return onY
-    ? (
-        el.scrollHeight > el.clientHeight && (
-          el.classList.contains('scroll')
-          || el.classList.contains('overflow-auto')
-          || [ 'auto', 'scroll' ].includes(window.getComputedStyle(el)[ 'overflow-y' ])
-        )
-      )
-    : (
-        el.scrollWidth > el.clientWidth && (
-          el.classList.contains('scroll')
-          || el.classList.contains('overflow-auto')
-          || [ 'auto', 'scroll' ].includes(window.getComputedStyle(el)[ 'overflow-x' ])
-        )
-      )
+    ? el.scrollHeight > el.clientHeight &&
+        (el.classList.contains('scroll') ||
+          el.classList.contains('overflow-auto') ||
+          ['auto', 'scroll'].includes(
+            window.getComputedStyle(el)['overflow-y']
+          ))
+    : el.scrollWidth > el.clientWidth &&
+        (el.classList.contains('scroll') ||
+          el.classList.contains('overflow-auto') ||
+          ['auto', 'scroll'].includes(
+            window.getComputedStyle(el)['overflow-x']
+          ))
 }
 
 export default {

package/src/utils/throttle/throttle.js

@@ -1,10 +1,13 @@
-export default function (fn, limit = 250) {
-  let wait = false, result
+export default function throttle(fn, limit = 250) {
+  let wait = false,
+    result
 
-  return function (/* ...args */) {
+  return function runThrottle(/* ...args */) {
     if (wait === false) {
       wait = true
-      setTimeout(() => { wait = false }, limit)
+      setTimeout(() => {
+        wait = false
+      }, limit)
       result = fn.apply(this, arguments)
     }
 

package/src/utils/throttle/throttle.test.js

@@ -1,7 +1,4 @@
-import {
-  describe, test, expect, vi,
-  beforeEach, afterEach
-} from 'vitest'
+import { describe, test, expect, vi, beforeEach, afterEach } from 'vitest'
 
 import throttle from './throttle.js'
 
@@ -18,9 +15,7 @@ describe('[throttle API]', () => {
   describe('[Functions]', () => {
     describe('[(function)default]', () => {
       test('has correct return value', () => {
-        expect(
-          throttle(() => {})
-        ).toBeTypeOf('function')
+        expect(throttle(() => {})).toBeTypeOf('function')
       })
 
       test('repeated rapid calls', () => {

package/src/utils/uid/uid.js

@@ -2,26 +2,24 @@
  * Based on the work of https://github.com/jchook/uuid-random
  */
 
-let
-  buf,
+let buf,
   bufIdx = 0
 const hexBytes = new Array(256)
 
 // Pre-calculate toString(16) for speed
 for (let i = 0; i < 256; i++) {
-  hexBytes[ i ] = (i + 0x100).toString(16).substring(1)
+  hexBytes[i] = (i + 0x100).toString(16).substring(1)
 }
 
 // Use best available PRNG
 const randomBytes = (() => {
   // Node & Browser support
-  const lib = typeof crypto !== 'undefined'
-    ? crypto
-    : (
-        typeof window !== 'undefined'
-          ? window.crypto || window.msCrypto
-          : void 0
-      )
+  const lib =
+    typeof crypto !== 'undefined'
+      ? crypto
+      : typeof window !== 'undefined'
+        ? window.crypto || window.msCrypto
+        : void 0
 
   if (lib !== void 0) {
     if (lib.randomBytes !== void 0) {
@@ -50,23 +48,37 @@ const randomBytes = (() => {
 // or improve speed by increasing this number (try 16384)
 const BUFFER_SIZE = 4096
 
-export default function () {
+export default function uid() {
   // Buffer some random bytes for speed
-  if (buf === void 0 || (bufIdx + 16 > BUFFER_SIZE)) {
+  if (buf === void 0 || bufIdx + 16 > BUFFER_SIZE) {
     bufIdx = 0
     buf = randomBytes(BUFFER_SIZE)
   }
 
   const b = Array.prototype.slice.call(buf, bufIdx, (bufIdx += 16))
-  b[ 6 ] = (b[ 6 ] & 0x0f) | 0x40
-  b[ 8 ] = (b[ 8 ] & 0x3f) | 0x80
+  b[6] = (b[6] & 0x0f) | 0x40
+  b[8] = (b[8] & 0x3f) | 0x80
 
-  return hexBytes[ b[ 0 ] ] + hexBytes[ b[ 1 ] ]
-    + hexBytes[ b[ 2 ] ] + hexBytes[ b[ 3 ] ] + '-'
-    + hexBytes[ b[ 4 ] ] + hexBytes[ b[ 5 ] ] + '-'
-    + hexBytes[ b[ 6 ] ] + hexBytes[ b[ 7 ] ] + '-'
-    + hexBytes[ b[ 8 ] ] + hexBytes[ b[ 9 ] ] + '-'
-    + hexBytes[ b[ 10 ] ] + hexBytes[ b[ 11 ] ]
-    + hexBytes[ b[ 12 ] ] + hexBytes[ b[ 13 ] ]
-    + hexBytes[ b[ 14 ] ] + hexBytes[ b[ 15 ] ]
+  return (
+    hexBytes[b[0]] +
+    hexBytes[b[1]] +
+    hexBytes[b[2]] +
+    hexBytes[b[3]] +
+    '-' +
+    hexBytes[b[4]] +
+    hexBytes[b[5]] +
+    '-' +
+    hexBytes[b[6]] +
+    hexBytes[b[7]] +
+    '-' +
+    hexBytes[b[8]] +
+    hexBytes[b[9]] +
+    '-' +
+    hexBytes[b[10]] +
+    hexBytes[b[11]] +
+    hexBytes[b[12]] +
+    hexBytes[b[13]] +
+    hexBytes[b[14]] +
+    hexBytes[b[15]]
+  )
 }