quasar 2.18.7 → 2.19.1

package/src/utils/event/event.js

@@ -6,7 +6,7 @@ export const listenOpts = {
 
 try {
   const opts = Object.defineProperty({}, 'passive', {
-    get () {
+    get() {
       Object.assign(listenOpts, {
         hasPassive: true,
         passive: { passive: true },
@@ -18,32 +18,29 @@ try {
   })
   window.addEventListener('qtest', null, opts)
   window.removeEventListener('qtest', null, opts)
-}
-catch (_) {}
+} catch {}
 
-export function noop () {}
+export function noop() {}
 
-export function leftClick (e) {
+export function leftClick(e) {
   return e.button === 0
 }
 
-export function middleClick (e) {
+export function middleClick(e) {
   return e.button === 1
 }
 
-export function rightClick (e) {
+export function rightClick(e) {
   return e.button === 2
 }
 
-export function position (e) {
-  if (e.touches && e.touches[ 0 ]) {
-    e = e.touches[ 0 ]
-  }
-  else if (e.changedTouches && e.changedTouches[ 0 ]) {
-    e = e.changedTouches[ 0 ]
-  }
-  else if (e.targetTouches && e.targetTouches[ 0 ]) {
-    e = e.targetTouches[ 0 ]
+export function position(e) {
+  if (e.touches && e.touches[0]) {
+    e = e.touches[0]
+  } else if (e.changedTouches && e.changedTouches[0]) {
+    e = e.changedTouches[0]
+  } else if (e.targetTouches && e.targetTouches[0]) {
+    e = e.targetTouches[0]
   }
 
   return {
@@ -52,7 +49,7 @@ export function position (e) {
   }
 }
 
-export function getEventPath (e) {
+export function getEventPath(e) {
   if (e.path) {
     return e.path
   }
@@ -77,12 +74,12 @@ export function getEventPath (e) {
 }
 
 // Reasonable defaults
-const
-  LINE_HEIGHT = 40,
+const LINE_HEIGHT = 40,
   PAGE_HEIGHT = 800
 
-export function getMouseWheelDistance (e) {
-  let x = e.deltaX, y = e.deltaY
+export function getMouseWheelDistance(e) {
+  let x = e.deltaX,
+    y = e.deltaY
 
   if ((x || y) && e.deltaMode) {
     const multiplier = e.deltaMode === 1 ? LINE_HEIGHT : PAGE_HEIGHT
@@ -91,63 +88,70 @@ export function getMouseWheelDistance (e) {
   }
 
   if (e.shiftKey && !x) {
-    [ y, x ] = [ x, y ]
+    ;[y, x] = [x, y]
   }
 
   return { x, y }
 }
 
-export function stop (e) {
+export function stop(e) {
   e.stopPropagation()
 }
 
-export function prevent (e) {
-  e.cancelable !== false && e.preventDefault()
+export function prevent(e) {
+  if (e.cancelable !== false) e.preventDefault()
 }
 
-export function stopAndPrevent (e) {
-  e.cancelable !== false && e.preventDefault()
+export function stopAndPrevent(e) {
+  if (e.cancelable !== false) e.preventDefault()
   e.stopPropagation()
 }
 
-export function preventDraggable (el, status) {
+export function preventDraggable(el, status) {
   if (el === void 0 || (status === true && el.__dragPrevented === true)) {
     return
   }
 
-  const fn = status === true
-    ? el => {
-      el.__dragPrevented = true
-      el.addEventListener('dragstart', prevent, listenOpts.notPassiveCapture)
-    }
-    : el => {
-      delete el.__dragPrevented
-      el.removeEventListener('dragstart', prevent, listenOpts.notPassiveCapture)
-    }
+  const fn =
+    status === true
+      ? element => {
+          element.__dragPrevented = true
+          element.addEventListener(
+            'dragstart',
+            prevent,
+            listenOpts.notPassiveCapture
+          )
+        }
+      : element => {
+          delete element.__dragPrevented
+          element.removeEventListener(
+            'dragstart',
+            prevent,
+            listenOpts.notPassiveCapture
+          )
+        }
 
   el.querySelectorAll('a, img').forEach(fn)
 }
 
-export function addEvt (ctx, targetName, events) {
-  const name = `__q_${ targetName }_evt`
+export function addEvt(ctx, targetName, events) {
+  const name = `__q_${targetName}_evt`
 
-  ctx[ name ] = ctx[ name ] !== void 0
-    ? ctx[ name ].concat(events)
-    : events
+  ctx[name] = ctx[name] !== void 0 ? ctx[name].concat(events) : events
 
   events.forEach(evt => {
-    evt[ 0 ].addEventListener(evt[ 1 ], ctx[ evt[ 2 ] ], listenOpts[ evt[ 3 ] ])
+    evt[0].addEventListener(evt[1], ctx[evt[2]], listenOpts[evt[3]])
   })
 }
 
-export function cleanEvt (ctx, targetName) {
-  const name = `__q_${ targetName }_evt`
+export function cleanEvt(ctx, targetName) {
+  const name = `__q_${targetName}_evt`
 
-  if (ctx[ name ] !== void 0) {
-    ctx[ name ].forEach(evt => {
-      evt[ 0 ].removeEventListener(evt[ 1 ], ctx[ evt[ 2 ] ], listenOpts[ evt[ 3 ] ])
+  if (ctx[name] !== void 0) {
+    ctx[name].forEach(evt => {
+      evt[0].removeEventListener(evt[1], ctx[evt[2]], listenOpts[evt[3]])
     })
-    ctx[ name ] = void 0
+    ctx[name] = void 0
   }
 }
 

package/src/utils/export-file/export-file.js

@@ -1,4 +1,4 @@
-function clean (link) {
+function clean(link) {
   // allow time for iOS
   setTimeout(() => {
     window.URL.revokeObjectURL(link.href)
@@ -27,17 +27,17 @@ function clean (link) {
  *                  Example: 'windows-1252' (ANSI, a subset of ISO-8859-1)
  *                  https://developer.mozilla.org/en-US/docs/Web/API/TextEncoder
  */
-export default function (fileName, rawData, opts = {}) {
-  const { mimeType, byteOrderMark, encoding } = typeof opts === 'string'
-    ? { mimeType: opts }
-    : opts
+export default function exportFile(fileName, rawData, opts = {}) {
+  const { mimeType, byteOrderMark, encoding } =
+    typeof opts === 'string' ? { mimeType: opts } : opts
 
-  const data = encoding !== void 0
-    ? (new TextEncoder(encoding)).encode([ rawData ])
-    : rawData
+  const data =
+    encoding !== void 0 ? new TextEncoder(encoding).encode([rawData]) : rawData
 
-  const blobData = byteOrderMark !== void 0 ? [ byteOrderMark, data ] : [ data ]
-  const blob = new Blob(blobData, { type: mimeType || 'application/octet-stream' })
+  const blobData = byteOrderMark !== void 0 ? [byteOrderMark, data] : [data]
+  const blob = new Blob(blobData, {
+    type: mimeType || 'application/octet-stream'
+  })
   const link = document.createElement('a')
 
   link.href = window.URL.createObjectURL(blob)
@@ -57,8 +57,7 @@ export default function (fileName, rawData, opts = {}) {
     link.click()
     clean(link)
     return true
-  }
-  catch (err) {
+  } catch (err) {
     clean(link)
     return err
   }

package/src/utils/extend/extend.js

@@ -1,41 +1,47 @@
-const
-  toString = Object.prototype.toString,
+const toString = Object.prototype.toString,
   hasOwn = Object.prototype.hasOwnProperty,
   notPlainObject = new Set(
-    [ 'Boolean', 'Number', 'String', 'Function', 'Array', 'Date', 'RegExp' ]
-      .map(name => '[object ' + name + ']')
+    ['Boolean', 'Number', 'String', 'Function', 'Array', 'Date', 'RegExp'].map(
+      name => '[object ' + name + ']'
+    )
   )
 
-function isPlainObject (obj) {
+function isPlainObject(obj) {
   if (obj !== Object(obj) || notPlainObject.has(toString.call(obj)) === true) {
     return false
   }
 
   if (
-    obj.constructor
-    && hasOwn.call(obj, 'constructor') === false
-    && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf') === false
+    obj.constructor &&
+    hasOwn.call(obj, 'constructor') === false &&
+    hasOwn.call(obj.constructor.prototype, 'isPrototypeOf') === false
   ) {
     return false
   }
 
   let key
-  for (key in obj) {} // eslint-disable-line
+  // oxlint-disable-next-line no-lone-blocks
+  for (key in obj) {
+  }
 
   return key === void 0 || hasOwn.call(obj, key)
 }
 
-export default function extend () {
-  let
-    options, name, src, copy, copyIsArray, clone,
-    target = arguments[ 0 ] || {},
+export default function extend() {
+  let options,
+    name,
+    src,
+    copy,
+    copyIsArray,
+    clone,
+    target = arguments[0] || {},
     i = 1,
     deep = false
   const length = arguments.length
 
   if (typeof target === 'boolean') {
     deep = target
-    target = arguments[ 1 ] || {}
+    target = arguments[1] || {}
     i = 2
   }
 
@@ -49,31 +55,29 @@ export default function extend () {
   }
 
   for (; i < length; i++) {
-    if ((options = arguments[ i ]) !== null) {
+    if ((options = arguments[i]) !== null) {
       for (name in options) {
-        src = target[ name ]
-        copy = options[ name ]
+        src = target[name]
+        copy = options[name]
 
         if (target === copy) {
           continue
         }
 
         if (
-          deep === true
-          && copy
-          && ((copyIsArray = Array.isArray(copy)) || isPlainObject(copy) === true)
+          deep === true &&
+          copy &&
+          ((copyIsArray = Array.isArray(copy)) || isPlainObject(copy) === true)
         ) {
           if (copyIsArray === true) {
             clone = Array.isArray(src) === true ? src : []
-          }
-          else {
+          } else {
             clone = isPlainObject(src) === true ? src : {}
           }
 
-          target[ name ] = extend(deep, clone, copy)
-        }
-        else if (copy !== void 0) {
-          target[ name ] = copy
+          target[name] = extend(deep, clone, copy)
+        } else if (copy !== void 0) {
+          target[name] = copy
         }
       }
     }

package/src/utils/extend/extend.test.js

@@ -6,73 +6,71 @@ describe('[extend API]', () => {
   describe('[Functions]', () => {
     describe('[(function)default]', () => {
       test('simple object', () => {
-        expect(
-          extend({}, { a: true, b: 2, c: 'str' })
-        ).toStrictEqual({ a: true, b: 2, c: 'str' })
+        expect(extend({}, { a: true, b: 2, c: 'str' })).toStrictEqual({
+          a: true,
+          b: 2,
+          c: 'str'
+        })
       })
 
       test('has correct return value', () => {
         const target = {}
         const result = extend(target, { a: true, b: 2, c: 'str' })
-        expect(
-          result
-        ).toBe(target)
+        expect(result).toBe(target)
       })
 
       test('extend object (deep)', () => {
-        expect(
-          extend(true, { a: { b: 2 } }, { a: { c: 3 } })
-        ).toStrictEqual({ a: { b: 2, c: 3 } })
+        expect(extend(true, { a: { b: 2 } }, { a: { c: 3 } })).toStrictEqual({
+          a: { b: 2, c: 3 }
+        })
       })
 
       test('extend object (not deep)', () => {
-        expect(
-          extend(false, { a: { b: 2 } }, { a: { c: 3 } })
-        ).toStrictEqual({ a: { c: 3 } })
+        expect(extend(false, { a: { b: 2 } }, { a: { c: 3 } })).toStrictEqual({
+          a: { c: 3 }
+        })
       })
 
       test('extend array (deep)', () => {
         expect(
-          extend(true, { a: [ 1, 2, [ 3, 4 ] ] }, { a: [ [ 5, 6 ] ] })
-        ).toStrictEqual({ a: [ [ 5, 6 ], 2, [ 3, 4 ] ] })
+          extend(true, { a: [1, 2, [3, 4]] }, { a: [[5, 6]] })
+        ).toStrictEqual({
+          a: [[5, 6], 2, [3, 4]]
+        })
       })
 
       test('extend array (not deep)', () => {
-        expect(
-          extend(false, { a: [ 1, 2 ] }, { a: [ 3 ] })
-        ).toStrictEqual({ a: [ 3 ] })
+        expect(extend(false, { a: [1, 2] }, { a: [3] })).toStrictEqual({
+          a: [3]
+        })
       })
 
       test('extend array with object', () => {
-        expect(
-          extend(true, { a: [ 1, { b: 2 } ] }, { a: [ 3 ] })
-        ).toStrictEqual({ a: [ 3, { b: 2 } ] })
+        expect(extend(true, { a: [1, { b: 2 }] }, { a: [3] })).toStrictEqual({
+          a: [3, { b: 2 }]
+        })
       })
 
       test.each([
-        [ 'boolean', true, false ],
-        [ 'number', 5, 6 ],
-        [ 'string', 'a', 'b' ],
-        [ 'undefined', undefined, null ],
-        [ 'NaN', NaN, Infinity ],
-        [ 'Infinity', Infinity, 5 ],
-        [ 'Date', new Date(150), new Date(200) ],
-        [ 'RegExp', /./, /.aaa/ ],
-        [ 'Array', [ 1, 2, 3 ], [ 1, 2, 3, 4 ] ],
-        [ 'Object', { a: true }, { a: false } ]
+        ['boolean', true, false],
+        ['number', 5, 6],
+        ['string', 'a', 'b'],
+        ['undefined', void 0, null],
+        ['NaN', NaN, Infinity],
+        ['Infinity', Infinity, 5],
+        ['Date', new Date(150), new Date(200)],
+        ['RegExp', /./, /.aaa/],
+        ['Array', [1, 2, 3], [1, 2, 3, 4]],
+        ['Object', { a: true }, { a: false }]
       ])('extend %s', (_, a, b) => {
-        expect(
-          extend({ a }, { a: b })
-        ).toStrictEqual({ a: b })
+        expect(extend({ a }, { a: b })).toStrictEqual({ a: b })
       })
 
       test('extend Date with object', () => {
         const date = new Date(150)
         const result = extend({}, { a: date }, { a: true })
 
-        expect(
-          result
-        ).toStrictEqual({ a: true })
+        expect(result).toStrictEqual({ a: true })
       })
 
       test('extend Fn', () => {
@@ -80,13 +78,9 @@ describe('[extend API]', () => {
         const fn2 = () => 6
         const result = extend({}, { a: fn1 }, { a: fn2 })
 
-        expect(
-          result
-        ).toStrictEqual({ a: fn2 })
+        expect(result).toStrictEqual({ a: fn2 })
 
-        expect(
-          result.a()
-        ).toBe(6)
+        expect(result.a()).toBe(6)
       })
     })
   })

package/src/utils/format/format.js

@@ -1,6 +1,6 @@
-const units = [ 'B', 'KB', 'MB', 'GB', 'TB', 'PB' ]
+const units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB']
 
-export function humanStorageSize (bytes, decimals = 1) {
+export function humanStorageSize(bytes, decimals = 1) {
   let u = 0
 
   while (parseInt(bytes, 10) >= 1024 && u < units.length - 1) {
@@ -8,27 +8,25 @@ export function humanStorageSize (bytes, decimals = 1) {
     ++u
   }
 
-  return `${ bytes.toFixed(decimals) }${ units[ u ] }`
+  return `${bytes.toFixed(decimals)}${units[u]}`
 }
 
-export function capitalize (str) {
+export function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1)
 }
 
-export function between (v, min, max) {
-  return max <= min
-    ? min
-    : Math.min(max, Math.max(min, v))
+export function between(v, min, max) {
+  return max <= min ? min : Math.min(max, Math.max(min, v))
 }
 
-export function normalizeToInterval (v, min, max) {
+export function normalizeToInterval(v, min, max) {
   if (max <= min) {
     return min
   }
 
-  const size = (max - min + 1)
+  const size = max - min + 1
 
-  let index = min + (v - min) % size
+  let index = min + ((v - min) % size)
   if (index < min) {
     index = size + index
   }
@@ -36,12 +34,12 @@ export function normalizeToInterval (v, min, max) {
   return index === 0 ? 0 : index // fix for (-a % a) => -0
 }
 
-export function pad (v, length = 2, char = '0') {
+export function pad(v, length = 2, char = '0') {
   if (v === void 0 || v === null) {
     return v
   }
 
-  const val = '' + v
+  const val = String(v)
   return val.length >= length
     ? val
     : new Array(length - val.length + 1).join(char) + val

package/src/utils/format/format.test.js

@@ -1,3 +1,5 @@
+// oxlint-disable import/no-named-as-default-member
+
 import { describe, test, expect } from 'vitest'
 
 import format from './format.js'
@@ -6,101 +8,88 @@ describe('[format API]', () => {
   describe('[Functions]', () => {
     describe('[(function)humanStorageSize]', () => {
       test.each([
-        [ '100.0B', 100 ],
-        [ '1.0KB', 1024 ],
-        [ '2.3KB', 1024 * 2.25 ],
-        [ '1.0MB', 1024 * 1024 ],
-        [ '1.0GB', 1024 * 1024 * 1024 ],
-        [ '1.0TB', 1024 * 1024 * 1024 * 1024 ],
-        [ '1.0PB', 1024 * 1024 * 1024 * 1024 * 1024 ]
+        ['100.0B', 100],
+        ['1.0KB', 1024],
+        ['2.3KB', 1024 * 2.25],
+        ['1.0MB', 1024 * 1024],
+        ['1.0GB', 1024 * 1024 * 1024],
+        ['1.0TB', 1024 * 1024 * 1024 * 1024],
+        ['1.0PB', 1024 * 1024 * 1024 * 1024 * 1024]
       ])('handles %s correctly', (expected, value) => {
-        expect(
-          format.humanStorageSize(value)
-        ).toBe(expected)
+        expect(format.humanStorageSize(value)).toBe(expected)
       })
 
       test.each([
-        [ '100.000B', 3, 100 ],
-        [ '1KB', 0, 1024 ],
-        [ '2.25KB', 2, 1024 * 2.25 ],
-        [ '2.2500KB', 4, 1024 * 2.25 ]
-      ])('handles %s with %d decimals correctly', (expected, decimals, value) => {
-        expect(
-          format.humanStorageSize(value, decimals)
-        ).toBe(expected)
-      })
+        ['100.000B', 3, 100],
+        ['1KB', 0, 1024],
+        ['2.25KB', 2, 1024 * 2.25],
+        ['2.2500KB', 4, 1024 * 2.25]
+      ])(
+        'handles %s with %d decimals correctly',
+        (expected, decimals, value) => {
+          expect(format.humanStorageSize(value, decimals)).toBe(expected)
+        }
+      )
     })
 
     describe('[(function)capitalize]', () => {
       test('has correct return value', () => {
-        expect(
-          format.capitalize('abc')
-        ).toBe('Abc')
+        expect(format.capitalize('abc')).toBe('Abc')
       })
     })
 
     describe('[(function)between]', () => {
       test.each([
-        [ 1, 0, 2, 1 ],
-        [ 10, 0, 5, 5 ],
-        [ 0, 0, 5, 0 ],
-        [ 5, 5, 5, 5 ],
-        [ 5, 5, 0, 5 ]
+        [1, 0, 2, 1],
+        [10, 0, 5, 5],
+        [0, 0, 5, 0],
+        [5, 5, 5, 5],
+        [5, 5, 0, 5]
       ])('between(%d, %d, %d)', (value, min, max, expected) => {
-        expect(
-          format.between(value, min, max)
-        ).toBe(expected)
+        expect(format.between(value, min, max)).toBe(expected)
       })
     })
 
     describe('[(function)normalizeToInterval]', () => {
       test.each([
-        [ 1, 0, 2, 1 ],
-        [ 10, 1, 5, 5 ],
-        [ 0, 0, 5, 0 ],
-        [ 5, 5, 5, 5 ],
-        [ 5, 5, 0, 5 ],
-        [ 15, 1, 5, 5 ],
-        [ 16, 1, 5, 1 ]
+        [1, 0, 2, 1],
+        [10, 1, 5, 5],
+        [0, 0, 5, 0],
+        [5, 5, 5, 5],
+        [5, 5, 0, 5],
+        [15, 1, 5, 5],
+        [16, 1, 5, 1]
       ])('normalizeToInterval(%d, %d, %d)', (value, min, max, expected) => {
-        expect(
-          format.normalizeToInterval(value, min, max)
-        ).toBe(expected)
+        expect(format.normalizeToInterval(value, min, max)).toBe(expected)
       })
     })
 
     describe('[(function)pad]', () => {
       test.each([
-        [ '1', '01' ],
-        [ '10', '10' ],
-        [ '100', '100' ],
-        [ 'a', '0a' ]
+        ['1', '01'],
+        ['10', '10'],
+        ['100', '100'],
+        ['a', '0a']
       ])('pad(%s)', (value, expected) => {
-        expect(
-          format.pad(value)
-        ).toBe(expected)
+        expect(format.pad(value)).toBe(expected)
       })
 
       test.each([
-        [ 'A', '00A' ],
-        [ 'A0', '0A0' ],
-        [ 'A00', 'A00' ],
-        [ 'a', '00a' ]
+        ['A', '00A'],
+        ['A0', '0A0'],
+        ['A00', 'A00'],
+        ['a', '00a']
       ])('pad(%s, 3)', (value, expected) => {
-        expect(
-          format.pad(value, 3)
-        ).toBe(expected)
+        expect(format.pad(value, 3)).toBe(expected)
       })
 
       test.each([
-        [ 'A', '-', '--A' ],
-        [ 'A0', '-', '-A0' ],
-        [ 'A00', '*', 'A00' ],
-        [ 'a', '*', '**a' ]
+        ['A', '-', '--A'],
+        ['A0', '-', '-A0'],
+        ['A00', '*', 'A00'],
+        ['a', '*', '**a']
       ])('pad(%s, 3, %s)', (value, char, expected) => {
-        expect(
-          format.pad(value, 3, char)
-        ).toBe(expected)
+        expect(format.pad(value, 3, char)).toBe(expected)
       })
     })
   })

package/src/utils/frame-debounce/frame-debounce.js

@@ -1,7 +1,9 @@
-export default function (fn) {
-  let wait = false, frame, callArgs
+export default function frameDebounce(fn) {
+  let wait = false,
+    frame,
+    callArgs
 
-  function debounced (/* ...args */) {
+  function debounced(/* ...args */) {
     callArgs = arguments
     if (wait === true) return