quasar 2.19.3 → 2.20.1

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

@@ -0,0 +1,183 @@
+import { describe, expect, test, vi } from 'vitest'
+import runSequentialPromises from './run-sequential-promises.js'
+
+// Helper to simulate asynchronous tasks
+const delay = (ms, value, shouldReject = false) => {
+  const { promise, resolve, reject } = Promise.withResolvers()
+  setTimeout(() => {
+    if (shouldReject) reject(value)
+    else resolve(value)
+  }, ms)
+
+  return promise
+}
+
+describe('[runSequentialPromises API]', () => {
+  describe('[Functions]', () => {
+    describe('[(function)default]', () => {
+      test('resolves with an empty array if passed an empty array', async () => {
+        const result = await runSequentialPromises([])
+        expect(result).toEqual([])
+      })
+
+      test('resolves with an empty object if passed an empty object', async () => {
+        const result = await runSequentialPromises({})
+        expect(result).toEqual({})
+      })
+
+      describe('Array Inputs', () => {
+        test('runs an array of promises and returns fulfilled statuses', async () => {
+          const tasks = [() => delay(10, 'first'), () => delay(10, 'second')]
+          const result = await runSequentialPromises(tasks)
+
+          expect(result).toEqual([
+            { key: 0, status: 'fulfilled', value: 'first' },
+            { key: 1, status: 'fulfilled', value: 'second' }
+          ])
+        })
+
+        test('passes the resultAggregator down to subsequent promises', async () => {
+          const tasks = [
+            () => delay(10, 'first'),
+            agg => delay(10, agg[0].value + ' and second')
+          ]
+
+          const result = await runSequentialPromises(tasks)
+
+          expect(result[1].value).toBe('first and second')
+        })
+      })
+
+      describe('Object Inputs', () => {
+        test('runs an object of promises and returns fulfilled statuses', async () => {
+          const tasks = {
+            taskA: () => delay(10, 'alpha'),
+            taskB: () => delay(10, 'beta')
+          }
+
+          const result = await runSequentialPromises(tasks)
+
+          expect(result).toEqual({
+            taskA: { key: 'taskA', status: 'fulfilled', value: 'alpha' },
+            taskB: { key: 'taskB', status: 'fulfilled', value: 'beta' }
+          })
+        })
+
+        test('passes the resultAggregator correctly for objects', async () => {
+          const tasks = {
+            taskA: () => delay(10, 100),
+            taskB: agg => delay(10, agg.taskA.value + 50)
+          }
+
+          const result = await runSequentialPromises(tasks)
+
+          expect(result.taskB.value).toBe(150)
+        })
+      })
+
+      describe('Error Handling (abortOnFail)', () => {
+        test('rejects immediately on first error if abortOnFail is true (default)', async () => {
+          const mockTask3 = vi.fn(() => delay(10, 'third'))
+
+          const tasks = [
+            () => delay(10, 'first'),
+            () => delay(10, new Error('Task 2 Failed'), true), // Rejects
+            mockTask3 // Should not run
+          ]
+
+          await expect(runSequentialPromises(tasks)).rejects.toMatchObject({
+            key: 1,
+            status: 'rejected',
+            reason: new Error('Task 2 Failed'),
+            resultAggregator: [
+              { key: 0, status: 'fulfilled', value: 'first' },
+              {
+                key: 1,
+                status: 'rejected',
+                reason: new Error('Task 2 Failed')
+              },
+              null // Task 3 never ran
+            ]
+          })
+
+          // Ensure the next task was aborted
+          expect(mockTask3).not.toHaveBeenCalled()
+        })
+
+        test('continues execution if abortOnFail is false and resolves with mixed results', async () => {
+          const mockTask3 = vi.fn(() => delay(10, 'third'))
+
+          const tasks = {
+            task1: () => delay(10, 'first'),
+            task2: () => delay(10, new Error('Task 2 Failed'), true), // Rejects
+            task3: mockTask3 // Should run
+          }
+
+          const result = await runSequentialPromises(tasks, {
+            abortOnFail: false
+          })
+
+          expect(result).toMatchObject({
+            task1: { key: 'task1', status: 'fulfilled', value: 'first' },
+            task2: {
+              key: 'task2',
+              status: 'rejected',
+              reason: new Error('Task 2 Failed')
+            },
+            task3: { key: 'task3', status: 'fulfilled', value: 'third' }
+          })
+
+          expect(mockTask3).toHaveBeenCalled()
+        })
+      })
+
+      describe('Concurrency Limits (threadsNumber)', () => {
+        test('processes tasks concurrently when threadsNumber > 1', async () => {
+          let runningTasks = 0
+          let maxConcurrency = 0
+
+          const trackConcurrency = async () => {
+            runningTasks++
+            maxConcurrency = Math.max(maxConcurrency, runningTasks)
+            await delay(20, 'done')
+            runningTasks--
+          }
+
+          const tasks = [
+            trackConcurrency,
+            trackConcurrency,
+            trackConcurrency,
+            trackConcurrency,
+            trackConcurrency
+          ]
+
+          await runSequentialPromises(tasks, { threadsNumber: 3 })
+
+          // If they ran sequentially, maxConcurrency would be 1.
+          // If threading worked, it should hit exactly 3.
+          expect(maxConcurrency).toBe(3)
+        })
+      })
+
+      describe('Edge Cases', () => {
+        test('wraps synchronous functions safely without crashing', async () => {
+          const tasks = [
+            () => 'sync value 1',
+            () => {
+              throw new Error('sync error')
+            },
+            () => 'sync value 2'
+          ]
+
+          // Because of the Promise.resolve() wrap in the implementation,
+          // this should cleanly reject rather than synchronously crashing Vitest
+          await expect(runSequentialPromises(tasks)).rejects.toMatchObject({
+            key: 1,
+            status: 'rejected',
+            reason: new Error('sync error')
+          })
+        })
+      })
+    })
+  })
+})

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

@@ -1,7 +1,7 @@
 import {
-  hasScrollbar,
+  getHorizontalScrollPosition,
   getVerticalScrollPosition,
-  getHorizontalScrollPosition
+  hasScrollbar
 } from './scroll.js'
 import { getEventPath, listenOpts, stopAndPrevent } from '../event/event.js'
 import { client } from '../../plugins/platform/Platform.js'
@@ -61,7 +61,7 @@ function onAppleScroll(e) {
 }
 
 function onAppleResize(evt) {
-  if (vpPendingUpdate === true) return
+  if (vpPendingUpdate) return
 
   vpPendingUpdate = true
 
@@ -117,8 +117,8 @@ function apply(action) {
     body.classList.add('q-body--prevent-scroll')
     document.qScrollPrevented = true
 
-    if (client.is.ios === true) {
-      if (hasViewport === true) {
+    if (client.is.ios) {
+      if (hasViewport) {
         window.scrollTo(0, 0)
         window.visualViewport.addEventListener(
           'resize',
@@ -141,14 +141,14 @@ function apply(action) {
     }
   }
 
-  if (client.is.desktop === true && client.is.mac === true) {
+  if (client.is.desktop && client.is.mac) {
     // ref. https://developers.google.com/web/updates/2017/01/scrolling-intervention
     window[`${action}EventListener`]('wheel', onWheel, listenOpts.notPassive)
   }
 
   if (action === 'remove') {
-    if (client.is.ios === true) {
-      if (hasViewport === true) {
+    if (client.is.ios) {
+      if (hasViewport) {
         window.visualViewport.removeEventListener(
           'resize',
           onAppleResize,
@@ -208,7 +208,7 @@ export default function preventScroll(state) {
 
     action = 'remove'
 
-    if (client.is.ios === true && client.is.nativeMobile === true) {
+    if (client.is.ios && client.is.nativeMobile) {
       if (closeTimer !== null) clearTimeout(closeTimer)
       closeTimer = setTimeout(() => {
         apply(action)

package/src/utils/scroll/scroll.js

@@ -48,8 +48,9 @@ export function getHorizontalScrollPosition(scrollTarget) {
     : scrollTarget.scrollLeft
 }
 
-export function animVerticalScrollTo(el, to, duration = 0 /* , prevTime */) {
-  const prevTime = arguments[3] === void 0 ? performance.now() : arguments[3]
+// oxlint-disable-next-line default-param-last
+export function animVerticalScrollTo(el, to, duration = 0, rawPrevTime) {
+  const prevTime = rawPrevTime === void 0 ? performance.now() : rawPrevTime
   const pos = getVerticalScrollPosition(el)
 
   if (duration <= 0) {
@@ -70,8 +71,9 @@ 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]
+// oxlint-disable-next-line default-param-last
+export function animHorizontalScrollTo(el, to, duration = 0, rawPrevTime) {
+  const prevTime = rawPrevTime === void 0 ? performance.now() : rawPrevTime
   const pos = getHorizontalScrollPosition(el)
 
   if (duration <= 0) {
@@ -151,9 +153,9 @@ export function getScrollbarWidth() {
     overflow: 'hidden'
   })
 
-  outer.appendChild(inner)
+  outer.append(inner)
 
-  document.body.appendChild(outer)
+  document.body.append(outer)
 
   const w1 = inner.offsetWidth
   outer.style.overflow = 'scroll'
@@ -169,6 +171,7 @@ export function getScrollbarWidth() {
   return size
 }
 
+const autoAndScroll = ['auto', 'scroll']
 export function hasScrollbar(el, onY = true) {
   if (!el || el.nodeType !== Node.ELEMENT_NODE) {
     return false
@@ -178,15 +181,11 @@ export function hasScrollbar(el, onY = true) {
     ? el.scrollHeight > el.clientHeight &&
         (el.classList.contains('scroll') ||
           el.classList.contains('overflow-auto') ||
-          ['auto', 'scroll'].includes(
-            window.getComputedStyle(el)['overflow-y']
-          ))
+          autoAndScroll.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']
-          ))
+          autoAndScroll.includes(window.getComputedStyle(el)['overflow-x']))
 }
 
 export default {

package/src/utils/throttle/throttle.js

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

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

@@ -1,4 +1,4 @@
-import { describe, test, expect, vi, beforeEach, afterEach } from 'vitest'
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
 
 import throttle from './throttle.js'
 

package/src/utils/uid/uid.js

@@ -1,84 +1,58 @@
-/**
- * Based on the work of https://github.com/jchook/uuid-random
- */
-
-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)
-}
-
-// Use best available PRNG
-const randomBytes = (() => {
-  // Node & Browser support
-  const lib =
-    typeof crypto !== 'undefined'
-      ? crypto
-      : typeof window !== 'undefined'
-        ? window.crypto || window.msCrypto
-        : void 0
-
-  if (lib !== void 0) {
-    if (lib.randomBytes !== void 0) {
-      return lib.randomBytes
-    }
-    if (lib.getRandomValues !== void 0) {
-      return n => {
-        const bytes = new Uint8Array(n)
-        lib.getRandomValues(bytes)
-        return bytes
-      }
+function createUidFn() {
+  if (typeof crypto === 'undefined') {
+    return () => {
+      throw new Error(
+        '[Quasar uid()] Secure RNG not available. Cannot generate collision-resistant UUID.'
+      )
     }
   }
 
-  return n => {
-    const r = []
-    for (let i = n; i > 0; i--) {
-      r.push(Math.floor(Math.random() * 256))
-    }
-    return r
-  }
-})()
+  // Fast Path: Native C++/Rust implementation (Node.js & HTTPS Browsers)
+  if (crypto.randomUUID) return () => crypto.randomUUID()
 
-// Buffer random numbers for speed
-// Reduce memory usage by decreasing this number (min 16)
-// or improve speed by increasing this number (try 16384)
-const BUFFER_SIZE = 4096
-
-export default function uid() {
-  // Buffer some random bytes for speed
-  if (buf === void 0 || bufIdx + 16 > BUFFER_SIZE) {
-    bufIdx = 0
-    buf = randomBytes(BUFFER_SIZE)
-  }
+  // Pre-compute hex map for the HTTP fallback
+  const hex = Array.from({ length: 256 }, (_, i) =>
+    (i + 0x1_00).toString(16).slice(1)
+  )
+  let buf, bufIdx
 
-  const b = Array.prototype.slice.call(buf, bufIdx, (bufIdx += 16))
-  b[6] = (b[6] & 0x0f) | 0x40
-  b[8] = (b[8] & 0x3f) | 0x80
+  return () => {
+    if (buf === void 0 || bufIdx + 16 > 4096) {
+      bufIdx = 0
+      buf = new Uint8Array(4096)
+      crypto.getRandomValues(buf)
+    }
 
-  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]]
-  )
+    const i = bufIdx
+    bufIdx += 16
+
+    // Set UUIDv4 version (4) and variant (8, 9, a, or b)
+    buf[i + 6] = (buf[i + 6] & 0x0f) | 0x40
+    buf[i + 8] = (buf[i + 8] & 0x3f) | 0x80
+
+    return (
+      hex[buf[i]] +
+      hex[buf[i + 1]] +
+      hex[buf[i + 2]] +
+      hex[buf[i + 3]] +
+      '-' +
+      hex[buf[i + 4]] +
+      hex[buf[i + 5]] +
+      '-' +
+      hex[buf[i + 6]] +
+      hex[buf[i + 7]] +
+      '-' +
+      hex[buf[i + 8]] +
+      hex[buf[i + 9]] +
+      '-' +
+      hex[buf[i + 10]] +
+      hex[buf[i + 11]] +
+      hex[buf[i + 12]] +
+      hex[buf[i + 13]] +
+      hex[buf[i + 14]] +
+      hex[buf[i + 15]]
+    )
+  }
 }
+
+export default createUidFn()

package/src/utils/uid/uid.test.js

@@ -1,10 +1,10 @@
-import { describe, test, expect } from 'vitest'
+import { describe, test } from 'vitest'
 
 import uid from './uid.js'
 
 describe('[uid API]', () => {
-  describe('[Functions]', () => {
-    describe('[(function)default]', () => {
+  describe('[Variables]', () => {
+    describe('[(variable)default]', () => {
       test('has correct return value', () => {
         const result = uid()
         expect(result).toBeTypeOf('string')

package/wrappers/index.cjs

@@ -4,7 +4,7 @@
 //  parameters and return value when using Quasar with TypeScript
 // We need these in `ui` folder to make `quasar/wrapper` import work,
 //  but they are useful only for Quasar CLI projects
-// They are typed via module augmentation by `@quasar/app-webpack` / `@quasar/app-vite`
+// They are typed via module augmentation by `@quasar/app-vite` / `@quasar/app-webpack`
 
 /*******************************************************
  * Warning!
@@ -12,7 +12,7 @@
  *    @quasar/app-vite v2
  *    @quasar/app-webpack v4
  *
- * Use the new wrappers from #q-app/wrappers
+ * Use the new wrappers from #q-app instead
  *******************************************************/
 
 module.exports.boot = function boot(callback) {

package/wrappers/index.js

@@ -4,7 +4,7 @@
 //  parameters and return value when using Quasar with TypeScript
 // We need these in `ui` folder to make `quasar/wrapper` import work,
 //  but they are useful only for Quasar CLI projects
-// They are typed via module augmentation by `@quasar/app-webpack` / `@quasar/app-vite`
+// They are typed via module augmentation by `@quasar/app-vite` / `@quasar/app-webpack`
 
 /*******************************************************
  * Warning!
@@ -12,7 +12,7 @@
  *    @quasar/app-vite v2
  *    @quasar/app-webpack v4
  *
- * Use the new wrappers from #q-app/wrappers
+ * Use the new wrappers from #q-app instead
  *******************************************************/
 
 export function boot(callback) {