quasar 2.19.3 → 2.20.0

package/src/utils/private.inject-obj-prop/inject-obj-prop.test.js

@@ -1,6 +1,6 @@
-import { describe, test, expect } from 'vitest'
+import { describe, expect, test } from 'vitest'
 
-import { injectProp, injectMultipleProps } from './inject-obj-prop.js'
+import { injectMultipleProps, injectProp } from './inject-obj-prop.js'
 
 describe('[injectObjProp API]', () => {
   describe('[Functions]', () => {

package/src/utils/private.keyboard/escape-key.js

@@ -9,17 +9,17 @@ function onKeydown(evt) {
 }
 
 function onBlur() {
-  if (escDown === true) {
+  if (escDown) {
     escDown = false
   }
 }
 
 function onKeyup(evt) {
-  if (escDown === true) {
+  if (escDown) {
     escDown = false
 
-    if (isKeyCode(evt, 27) === true) {
-      handlers[handlers.length - 1](evt)
+    if (isKeyCode(evt, 27)) {
+      handlers.at(-1)(evt)
     }
   }
 }
@@ -32,7 +32,7 @@ function update(action) {
 }
 
 export function addEscapeKey(fn) {
-  if (client.is.desktop === true) {
+  if (client.is.desktop) {
     handlers.push(fn)
 
     if (handlers.length === 1) {

package/src/utils/private.keyboard/escape-key.test.js

@@ -1,4 +1,4 @@
-import { describe, test, expect, vi, afterEach } from 'vitest'
+import { afterEach, describe, expect, test, vi } from 'vitest'
 
 import { addEscapeKey, removeEscapeKey } from './escape-key.js'
 

package/src/utils/private.keyboard/key-composition.js

@@ -6,15 +6,13 @@ export function onKeyDownComposition(evt) {
 
 export function shouldIgnoreKey(evt) {
   return (
-    lastKeyCompositionStatus === true ||
+    lastKeyCompositionStatus ||
     evt !== Object(evt) ||
-    evt.isComposing === true ||
-    evt.qKeyEvent === true
+    evt.isComposing ||
+    evt.qKeyEvent
   )
 }
 
 export function isKeyCode(evt, keyCodes) {
-  return shouldIgnoreKey(evt) === true
-    ? false
-    : [].concat(keyCodes).includes(evt.keyCode)
+  return !shouldIgnoreKey(evt) && [keyCodes].flat().includes(evt.keyCode)
 }

package/src/utils/private.noop-ssr-directive-transform/noop-ssr-directive-transform.js

@@ -1 +1,3 @@
-export default () => ({})
+export default function noopSsrDirectiveTransform() {
+  return {}
+}

package/src/utils/private.noop-ssr-directive-transform/noop-ssr-directive-transform.test.js

@@ -1,4 +1,4 @@
-import { describe, test, expect } from 'vitest'
+import { describe, expect, test } from 'vitest'
 
 import noopSsrDirectiveTransform from './noop-ssr-directive-transform.js'
 

package/src/utils/private.portal/portal.js

@@ -14,10 +14,10 @@ export function closePortalMenus(proxy, evt) {
       proxy.hide(evt)
 
       // is this a point of separation?
-      if (proxy.$props.separateClosePopup === true) {
+      if (proxy.$props.separateClosePopup) {
         return getParentProxy(proxy)
       }
-    } else if (proxy.__qPortal === true) {
+    } else if (proxy.__qPortal) {
       // treat it as point of separation if parent is QPopupProxy
       // (so mobile matches desktop behavior)
       // and hide it too
@@ -26,9 +26,9 @@ export function closePortalMenus(proxy, evt) {
       if (parent?.$options.name === 'QPopupProxy') {
         proxy.hide(evt)
         return parent
-      } else {
-        return proxy
       }
+
+      return proxy
     }
 
     proxy = getParentProxy(proxy)
@@ -37,7 +37,7 @@ export function closePortalMenus(proxy, evt) {
 
 export function closePortals(proxy, evt, depth) {
   while (depth !== 0 && proxy !== void 0 && proxy !== null) {
-    if (proxy.__qPortal === true) {
+    if (proxy.__qPortal) {
       depth--
 
       if (proxy.$options.name === 'QMenu') {

package/src/utils/private.position-engine/position-engine.js

@@ -2,37 +2,36 @@ import { getScrollbarWidth } from '../scroll/scroll.js'
 import { client } from '../../plugins/platform/Platform.js'
 
 let vpLeft, vpTop
+const partsFirst = ['top', 'center', 'bottom'],
+  partsSecond = ['left', 'middle', 'right', 'start', 'end']
 
 export function validatePosition(pos) {
   const parts = pos.split(' ')
-  if (parts.length !== 2) {
-    return false
-  }
-  if (['top', 'center', 'bottom'].includes(parts[0]) !== true) {
+  if (parts.length !== 2) return false
+
+  if (!partsFirst.includes(parts[0])) {
     console.error(
       'Anchor/Self position must start with one of top/center/bottom'
     )
     return false
   }
-  if (['left', 'middle', 'right', 'start', 'end'].includes(parts[1]) !== true) {
+  if (!partsSecond.includes(parts[1])) {
     console.error(
       'Anchor/Self position must end with one of left/middle/right/start/end'
     )
     return false
   }
+
   return true
 }
 
 export function validateOffset(val) {
-  if (!val) {
-    return true
-  }
-  if (val.length !== 2) {
-    return false
-  }
+  if (!val) return true
+  if (val.length !== 2) return false
   if (typeof val[0] !== 'number' || typeof val[1] !== 'number') {
     return false
   }
+
   return true
 }
 
@@ -52,7 +51,7 @@ export function parsePosition(pos, rtl) {
   const parts = pos.split(' ')
   return {
     vertical: parts[0],
-    horizontal: horizontalPos[`${parts[1]}#${rtl === true ? 'rtl' : 'ltr'}`]
+    horizontal: horizontalPos[`${parts[1]}#${rtl ? 'rtl' : 'ltr'}`]
   }
 }
 
@@ -154,7 +153,7 @@ export function setPosition(cfg, retryNumber = 0) {
     maxWidth
   } = cfg
 
-  if (client.is.ios === true && window.visualViewport !== void 0) {
+  if (client.is.ios && window.visualViewport !== void 0) {
     // uses the q-position-engine CSS class
 
     const el = document.body.style
@@ -178,7 +177,7 @@ export function setPosition(cfg, retryNumber = 0) {
 
   const anchorProps =
     absoluteOffset === void 0
-      ? getAnchorProps(anchorEl, cover === true ? [0, 0] : offset)
+      ? getAnchorProps(anchorEl, cover ? [0, 0] : offset)
       : getAbsoluteAnchorProps(anchorEl, absoluteOffset, offset)
 
   /**
@@ -202,21 +201,20 @@ export function setPosition(cfg, retryNumber = 0) {
 
   const { offsetWidth: origElWidth, offsetHeight: origElHeight } = targetEl
   const { elWidth, elHeight } =
-    fit === true || cover === true
+    fit || cover
       ? {
           elWidth: Math.max(anchorProps.width, origElWidth),
-          elHeight:
-            cover === true
-              ? Math.max(anchorProps.height, origElHeight)
-              : origElHeight
+          elHeight: cover
+            ? Math.max(anchorProps.height, origElHeight)
+            : origElHeight
         }
       : { elWidth: origElWidth, elHeight: origElHeight }
 
   let elStyle = { maxWidth, maxHeight }
 
-  if (fit === true || cover === true) {
+  if (fit || cover) {
     elStyle.minWidth = anchorProps.width + 'px'
-    if (cover === true) {
+    if (cover) {
       elStyle.minHeight = anchorProps.height + 'px'
     }
   }
@@ -258,7 +256,7 @@ export function setPosition(cfg, retryNumber = 0) {
       anchorProps.right -= offsetX + 2
     }
 
-    if (hasChanged === true) {
+    if (hasChanged) {
       // re-calculate props with the new anchor
       props = getTopLeftProps(
         anchorProps,

package/src/utils/private.render/render.js

@@ -8,7 +8,7 @@ export function hUniqueSlot(slot, otherwise) {
   if (slot !== void 0) {
     const vnode = slot()
     if (vnode !== void 0 && vnode !== null) {
-      return vnode.slice()
+      return [...vnode]
     }
   }
 
@@ -20,6 +20,7 @@ export function hUniqueSlot(slot, otherwise) {
  * so it's merged with the possible slot
  */
 export function hMergeSlot(slot, source) {
+  // oxlint-disable-next-line unicorn/prefer-spread
   return slot !== void 0 ? source.concat(slot()) : source
 }
 
@@ -28,10 +29,9 @@ export function hMergeSlot(slot, source) {
  * even if source might not exist
  */
 export function hMergeSlotSafely(slot, source) {
-  if (slot === void 0) {
-    return source
-  }
+  if (slot === void 0) return source
 
+  // oxlint-disable-next-line unicorn/prefer-spread
   return source !== void 0 ? source.concat(slot()) : slot()
 }
 
@@ -41,8 +41,6 @@ export function hMergeSlotSafely(slot, source) {
  */
 export function hDir(tag, data, children, key, condition, getDirsFn) {
   data.key = key + condition
-
   const vnode = h(tag, data, children)
-
-  return condition === true ? withDirectives(vnode, getDirsFn()) : vnode
+  return condition ? withDirectives(vnode, getDirsFn()) : vnode
 }

package/src/utils/private.render/render.test.js

@@ -1,13 +1,13 @@
-import { describe, test, expect } from 'vitest'
-import { mount, flushPromises } from '@vue/test-utils'
+import { describe, expect, test } from 'vitest'
+import { flushPromises, mount } from '@vue/test-utils'
 import { ref } from 'vue'
 
 import {
-  hSlot,
-  hUniqueSlot,
+  hDir,
   hMergeSlot,
   hMergeSlotSafely,
-  hDir
+  hSlot,
+  hUniqueSlot
 } from './render.js'
 
 describe('[render API]', () => {

package/src/utils/private.rtl/rtl.js

@@ -1,3 +1,4 @@
+// oxlint-disable-next-line import/no-mutable-exports
 let rtlHasScrollBug = false
 
 // mobile Chrome takes the crown for this
@@ -16,8 +17,8 @@ if (!__QUASAR_SSR__) {
     height: '1px'
   })
 
-  document.body.appendChild(scroller)
-  scroller.appendChild(spacer)
+  document.body.append(scroller)
+  scroller.append(spacer)
   scroller.scrollLeft = -1000
 
   rtlHasScrollBug = scroller.scrollLeft >= 0

package/src/utils/private.rtl/rtl.test.js

@@ -1,4 +1,4 @@
-import { describe, test, expect } from 'vitest'
+import { describe, expect, test } from 'vitest'
 
 import { rtlHasScrollBug } from './rtl.js'
 

package/src/utils/private.selection/selection.js

@@ -7,7 +7,7 @@ export function clearSelection() {
       selection.empty()
     } else if (selection.removeAllRanges !== void 0) {
       selection.removeAllRanges()
-      if (Platform.is.mobile !== true) {
+      if (!Platform.is.mobile) {
         selection.addRange(document.createRange())
       }
     }

package/src/utils/private.selection/selection.test.js

@@ -1,4 +1,4 @@
-import { describe, test, expect, onTestFinished } from 'vitest'
+import { describe, expect, onTestFinished, test } from 'vitest'
 
 import { clearSelection } from './selection.js'
 
@@ -15,7 +15,7 @@ describe('[selection API]', () => {
         const el = document.createElement('div')
         el.innerHTML = '<address>quasar@email.com</address>'
 
-        document.body.appendChild(el)
+        document.body.append(el)
 
         onTestFinished(() => {
           el.remove()

package/src/utils/private.sort/sort.test.js

@@ -1,6 +1,6 @@
-import { describe, test, expect } from 'vitest'
+import { describe, expect, test } from 'vitest'
 
-import { sortDate, sortBoolean } from './sort.js'
+import { sortBoolean, sortDate } from './sort.js'
 
 describe('[sort API]', () => {
   describe('[Functions]', () => {

package/src/utils/private.touch/touch.js

@@ -15,28 +15,24 @@ export function getModifierDirections(mod) {
   const dir = {}
 
   for (const direction of directionList) {
-    if (mod[direction] === true) {
-      dir[direction] = true
-    }
+    if (mod[direction]) dir[direction] = true
   }
 
-  if (Object.keys(dir).length === 0) {
-    return modifiersAll
-  }
+  if (Object.keys(dir).length === 0) return modifiersAll
 
-  if (dir.horizontal === true) {
+  if (dir.horizontal) {
     dir.left = dir.right = true
-  } else if (dir.left === true && dir.right === true) {
+  } else if (dir.left && dir.right) {
     dir.horizontal = true
   }
 
-  if (dir.vertical === true) {
+  if (dir.vertical) {
     dir.up = dir.down = true
-  } else if (dir.up === true && dir.down === true) {
+  } else if (dir.up && dir.down) {
     dir.vertical = true
   }
 
-  if (dir.horizontal === true && dir.vertical === true) {
+  if (dir.horizontal && dir.vertical) {
     dir.all = true
   }
 
@@ -54,9 +50,9 @@ export function shouldStart(evt, ctx) {
   return (
     ctx.event === void 0 &&
     evt.target !== void 0 &&
-    evt.target.draggable !== true &&
+    !evt.target.draggable &&
     typeof ctx.handler === 'function' &&
-    avoidNodeNamesList.includes(evt.target.nodeName.toUpperCase()) === false &&
-    (evt.qClonedBy === void 0 || evt.qClonedBy.indexOf(ctx.uid) === -1)
+    !avoidNodeNamesList.includes(evt.target.nodeName.toUpperCase()) &&
+    (evt.qClonedBy === void 0 || !evt.qClonedBy.includes(ctx.uid))
   )
 }

package/src/utils/private.touch/touch.test.js

@@ -1,4 +1,4 @@
-import { describe, test, expect } from 'vitest'
+import { describe, expect, test } from 'vitest'
 import { mount } from '@vue/test-utils'
 
 import { getModifierDirections, shouldStart } from './touch.js'

package/src/utils/private.vm/vm.js

@@ -17,7 +17,7 @@ export function getParentProxy(proxy) {
 
 function fillNormalizedVNodes(children, vnode) {
   if (typeof vnode.type === 'symbol') {
-    if (Array.isArray(vnode.children) === true) {
+    if (Array.isArray(vnode.children)) {
       vnode.children.forEach(child => {
         fillNormalizedVNodes(children, child)
       })
@@ -35,7 +35,7 @@ export function getNormalizedVNodes(vnodes) {
     fillNormalizedVNodes(children, vnode)
   })
 
-  return Array.from(children)
+  return [...children]
 }
 
 export function vmHasRouter(vm) {

package/src/utils/private.vm/vm.test.js

@@ -1,10 +1,10 @@
-import { describe, test, expect } from 'vitest'
-import { mount, flushPromises } from '@vue/test-utils'
-import { h, getCurrentInstance } from 'vue'
+import { describe, expect, test } from 'vitest'
+import { flushPromises, mount } from '@vue/test-utils'
+import { getCurrentInstance, h } from 'vue'
 
 import {
-  getParentProxy,
   getNormalizedVNodes,
+  getParentProxy,
   vmHasRouter,
   vmIsDestroyed
 } from './vm.js'

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

@@ -1,23 +1,22 @@
 function parsePromises(sequentialPromises) {
-  const isList = Array.isArray(sequentialPromises)
-
-  if (isList === true) {
+  if (Array.isArray(sequentialPromises)) {
     const totalJobs = sequentialPromises.length
     return {
-      isList,
+      isList: true,
       totalJobs,
+      // oxlint-disable-next-line unicorn/new-for-builtins
       resultAggregator: Array(totalJobs).fill(null)
     }
   }
 
   const resultKeys = Object.keys(sequentialPromises)
-  const resultAggregator = {}
-  resultKeys.forEach(keyName => {
-    resultAggregator[keyName] = null
-  })
+  const resultAggregator = resultKeys.reduce((acc, key) => {
+    acc[key] = null
+    return acc
+  }, {})
 
   return {
-    isList,
+    isList: false,
     totalJobs: resultKeys.length,
     resultAggregator,
     resultKeys
@@ -67,57 +66,48 @@ export default function runSequentialPromises(
   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
-            }
+  if (totalJobs === 0) return Promise.resolve(resultAggregator)
 
-            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 maxJobIndex = totalJobs - 1
+  const runNextPromise = threadCtx => {
+    if (hasAborted || jobIndex >= maxJobIndex) {
+      return threadCtx.resolve()
+    }
 
-            const result = { key, status: 'rejected', reason }
-            resultAggregator[key] = result
+    const currentJobIndex = ++jobIndex
+    const key = isList ? currentJobIndex : resultKeys[currentJobIndex]
 
-            if (abortOnFail === true) {
-              hasAborted = true
-              reject({ ...result, resultAggregator })
-              return // early exit
-            }
+    // Promise.resolve() protects against synchronous errors if the user
+    // accidentally passes a normal function instead of an async one.
+    Promise.resolve()
+      .then(() => sequentialPromises[key](resultAggregator))
+      .then(value => {
+        if (!hasAborted) {
+          resultAggregator[key] = { key, status: 'fulfilled', value }
+        }
+      })
+      .catch(err => {
+        if (hasAborted) return
 
-            // timeout so no interference
-            setTimeout(runNextPromise)
-          })
-      }
+        const result = { key, status: 'rejected', reason: err }
+        resultAggregator[key] = result
 
-      runNextPromise()
-    })
+        if (abortOnFail) {
+          hasAborted = true
+          threadCtx.reject({ ...result, resultAggregator })
+        }
+      })
+      .finally(() => {
+        if (!hasAborted) runNextPromise(threadCtx)
+      })
+  }
 
-  const threads = Array(Math.min(totalJobs, threadsNumber))
-    .fill(null)
-    .map(getPromiseThread)
+  const concurrencyLimit = Math.min(totalJobs, Math.max(1, threadsNumber))
+  const threads = Array.from({ length: concurrencyLimit }, () => {
+    const threadCtx = Promise.withResolvers()
+    runNextPromise(threadCtx)
+    return threadCtx.promise
+  })
 
   return Promise.all(threads).then(() => resultAggregator)
 }