quasar 2.18.7 → 2.19.1

package/src/utils/frame-debounce/frame-debounce.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 frameDebounce from './frame-debounce.js'
 
@@ -20,13 +17,9 @@ describe('[frameDebounce API]', () => {
       test('has correct return value', () => {
         const fn = frameDebounce(() => {})
 
-        expect(
-          fn
-        ).toBeTypeOf('function')
+        expect(fn).toBeTypeOf('function')
 
-        expect(
-          fn.cancel
-        ).toBeTypeOf('function')
+        expect(fn.cancel).toBeTypeOf('function')
       })
 
       test('should debounce with fast timeout', () => {

package/src/utils/is/is.js

@@ -1,9 +1,12 @@
-export function isDeepEqual (a, b) {
-  if (a === b) {
-    return true
-  }
-
-  if (a !== null && b !== null && typeof a === 'object' && typeof b === 'object') {
+export function isDeepEqual(a, b) {
+  if (a === b) return true
+
+  if (
+    a !== null &&
+    b !== null &&
+    typeof a === 'object' &&
+    typeof b === 'object'
+  ) {
     if (a.constructor !== b.constructor) {
       return false
     }
@@ -17,8 +20,8 @@ export function isDeepEqual (a, b) {
         return false
       }
 
-      for (i = length; i-- !== 0;) {
-        if (isDeepEqual(a[ i ], b[ i ]) !== true) {
+      for (i = length; i-- !== 0; ) {
+        if (isDeepEqual(a[i], b[i]) !== true) {
           return false
         }
       }
@@ -35,7 +38,7 @@ export function isDeepEqual (a, b) {
 
       i = iter.next()
       while (i.done !== true) {
-        if (b.has(i.value[ 0 ]) !== true) {
+        if (b.has(i.value[0]) !== true) {
           return false
         }
         i = iter.next()
@@ -44,7 +47,7 @@ export function isDeepEqual (a, b) {
       iter = a.entries()
       i = iter.next()
       while (i.done !== true) {
-        if (isDeepEqual(i.value[ 1 ], b.get(i.value[ 0 ])) !== true) {
+        if (isDeepEqual(i.value[1], b.get(i.value[0])) !== true) {
           return false
         }
         i = iter.next()
@@ -62,7 +65,7 @@ export function isDeepEqual (a, b) {
 
       i = iter.next()
       while (i.done !== true) {
-        if (b.has(i.value[ 0 ]) !== true) {
+        if (b.has(i.value[0]) !== true) {
           return false
         }
         i = iter.next()
@@ -71,6 +74,7 @@ export function isDeepEqual (a, b) {
       return true
     }
 
+    // oxlint-disable-next-line eqeqeq
     if (a.buffer != null && a.buffer.constructor === ArrayBuffer) {
       length = a.length
 
@@ -78,8 +82,8 @@ export function isDeepEqual (a, b) {
         return false
       }
 
-      for (i = length; i-- !== 0;) {
-        if (a[ i ] !== b[ i ]) {
+      for (i = length; i-- !== 0; ) {
+        if (a[i] !== b[i]) {
           return false
         }
       }
@@ -99,16 +103,16 @@ export function isDeepEqual (a, b) {
       return a.toString() === b.toString()
     }
 
-    const keys = Object.keys(a).filter(key => a[ key ] !== void 0)
+    const keys = Object.keys(a).filter(key => a[key] !== void 0)
     length = keys.length
 
-    if (length !== Object.keys(b).filter(key => b[ key ] !== void 0).length) {
+    if (length !== Object.keys(b).filter(key => b[key] !== void 0).length) {
       return false
     }
 
-    for (i = length; i-- !== 0;) {
-      const key = keys[ i ]
-      if (isDeepEqual(a[ key ], b[ key ]) !== true) {
+    for (i = length; i-- !== 0; ) {
+      const key = keys[i]
+      if (isDeepEqual(a[key], b[key]) !== true) {
         return false
       }
     }
@@ -117,24 +121,24 @@ export function isDeepEqual (a, b) {
   }
 
   // true if both NaN, false otherwise
-  return a !== a && b !== b // eslint-disable-line no-self-compare
+  return a !== a && b !== b
 }
 
 // not perfect, but what we ARE interested is for Arrays not to slip in
 // as spread operator will mess things up in various areas
-export function isObject (v) {
+export function isObject(v) {
   return v !== null && typeof v === 'object' && Array.isArray(v) !== true
 }
 
-export function isDate (v) {
+export function isDate(v) {
   return Object.prototype.toString.call(v) === '[object Date]'
 }
 
-export function isRegexp (v) {
+export function isRegexp(v) {
   return Object.prototype.toString.call(v) === '[object RegExp]'
 }
 
-export function isNumber (v) {
+export function isNumber(v) {
   return typeof v === 'number' && isFinite(v)
 }
 

package/src/utils/is/is.test.js

@@ -6,119 +6,135 @@ describe('[is API]', () => {
   describe('[Functions]', () => {
     describe('[(function)deepEqual]', () => {
       test.each([
-        [ 'Number', 5, 5 ],
-        [ 'String', 'a', 'a' ],
-        [ 'Boolean', true, true ],
-        [ 'Null', null, null ],
-        [ 'Undefined', undefined, undefined ],
-        [ 'NaN', NaN, NaN ],
-        [ 'Infinity', Infinity, Infinity ],
-        [ 'Date', new Date(150), new Date(150) ],
-        [ 'RegExp', /./, /./ ],
-        [ 'Array', [ 1, 2, 3 ], [ 1, 2, 3 ] ],
-        [ 'Map', new Map([ [ 1, 'one' ], [ 2, 'two' ] ]), new Map([ [ 1, 'one' ], [ 2, 'two' ] ]) ],
-        [ 'Deep Map', new Map([ [ 1, { a: { b: { c: { d: 5 } } } } ], [ 2, 'two' ] ]), new Map([ [ 1, { a: { b: { c: { d: 5 } } } } ], [ 2, 'two' ] ]) ],
-        [ 'Object', { a: true, b: false }, { a: true, b: false } ],
-        [ 'Deep object', { a: { b: { c: { d: 5 } } } }, { a: { b: { c: { d: 5 } } } } ],
-        [ 'Array', [ 1, 2, 3 ], [ 1, 2, 3 ] ],
-        [ 'Deep array', [ 1, { a: true, b: { c: 1 } } ], [ 1, { a: true, b: { c: 1 } } ] ],
-        [ 'Set', new Set([ 1, 2, 3 ]), new Set([ 1, 2, 3 ]) ]
+        ['Number', 5, 5],
+        ['String', 'a', 'a'],
+        ['Boolean', true, true],
+        ['Null', null, null],
+        ['Undefined', void 0, void 0],
+        ['NaN', NaN, NaN],
+        ['Infinity', Infinity, Infinity],
+        ['Date', new Date(150), new Date(150)],
+        ['RegExp', /./, /./],
+        ['Array', [1, 2, 3], [1, 2, 3]],
+        [
+          'Map',
+          new Map([
+            [1, 'one'],
+            [2, 'two']
+          ]),
+          new Map([
+            [1, 'one'],
+            [2, 'two']
+          ])
+        ],
+        [
+          'Deep Map',
+          new Map([
+            [1, { a: { b: { c: { d: 5 } } } }],
+            [2, 'two']
+          ]),
+          new Map([
+            [1, { a: { b: { c: { d: 5 } } } }],
+            [2, 'two']
+          ])
+        ],
+        ['Object', { a: true, b: false }, { a: true, b: false }],
+        [
+          'Deep object',
+          { a: { b: { c: { d: 5 } } } },
+          { a: { b: { c: { d: 5 } } } }
+        ],
+        ['Array', [1, 2, 3], [1, 2, 3]],
+        [
+          'Deep array',
+          [1, { a: true, b: { c: 1 } }],
+          [1, { a: true, b: { c: 1 } }]
+        ],
+        ['Set', new Set([1, 2, 3]), new Set([1, 2, 3])]
       ])('deepEqual(%s) matching', (_, a, b) => {
-        expect(
-          is.deepEqual(a, b)
-        ).toBe(true)
+        expect(is.deepEqual(a, b)).toBe(true)
       })
 
       test.each([
-        [ '5, 6', 5, 6 ],
-        [ '5, str(5)', 5, '5' ],
-        [ '5, null', 5, null ],
-        [ '5, undefined', 5, undefined ],
-        [ '5, NaN', 5, NaN ],
-        [ '5, Infinity', 5, Infinity ],
-        [ '5, {}', 5, {} ],
-        [ '5, []', 5, [] ],
-        [ '5, Date', 5, new Date() ],
-        [ '5, /./', 5, /./ ],
-        [ '5, Map()', 5, new Map([ [ 5, 'five' ] ]) ],
-        [ '5, Set()', 5, new Set([ 5 ]) ],
-        [ '5, Fn', 5, () => 5 ]
+        ['5, 6', 5, 6],
+        ['5, str(5)', 5, '5'],
+        ['5, null', 5, null],
+        ['5, undefined', 5, void 0],
+        ['5, NaN', 5, NaN],
+        ['5, Infinity', 5, Infinity],
+        ['5, {}', 5, {}],
+        ['5, []', 5, []],
+        ['5, Date', 5, new Date()],
+        ['5, /./', 5, /./],
+        ['5, Map()', 5, new Map([[5, 'five']])],
+        ['5, Set()', 5, new Set([5])],
+        ['5, Fn', 5, () => 5]
       ])('deepEqual(%s)', (_, a, b) => {
-        expect(
-          is.deepEqual(a, b)
-        ).toBe(false)
+        expect(is.deepEqual(a, b)).toBe(false)
       })
     })
 
     describe('[(function)object]', () => {
       test.each([
-        [ '{}', {}, true ],
-        [ '{ a: true }', { a: true }, true ],
-        [ '[]', [], false ],
-        [ '5', 5, false ],
-        [ 'null', null, false ],
-        [ 'undefined', undefined, false ],
-        [ 'NaN', NaN, false ],
-        [ 'Infinity', Infinity, false ],
-        [ 'Symbol()', Symbol('q'), false ]
+        ['{}', {}, true],
+        ['{ a: true }', { a: true }, true],
+        ['[]', [], false],
+        ['5', 5, false],
+        ['null', null, false],
+        ['undefined', void 0, false],
+        ['NaN', NaN, false],
+        ['Infinity', Infinity, false],
+        ['Symbol()', Symbol('q'), false]
       ])('has correct return value for %s', (_, value, expected) => {
-        expect(
-          is.object(value)
-        ).toBe(expected)
+        expect(is.object(value)).toBe(expected)
       })
     })
 
     describe('[(function)date]', () => {
       test.each([
-        [ 'new Date()', new Date(), true ],
-        [ 'Date.now()', Date.now(), false ],
-        [ '5', 5, false ],
-        [ '{}', {}, false ],
-        [ 'null', null, false ],
-        [ 'undefined', undefined, false ],
-        [ 'NaN', NaN, false ],
-        [ 'Infinity', Infinity, false ],
-        [ 'Symbol()', Symbol('q'), false ]
+        ['new Date()', new Date(), true],
+        ['Date.now()', Date.now(), false],
+        ['5', 5, false],
+        ['{}', {}, false],
+        ['null', null, false],
+        ['undefined', void 0, false],
+        ['NaN', NaN, false],
+        ['Infinity', Infinity, false],
+        ['Symbol()', Symbol('q'), false]
       ])('has correct return value for %s', (_, value, expected) => {
-        expect(
-          is.date(value)
-        ).toBe(expected)
+        expect(is.date(value)).toBe(expected)
       })
     })
 
     describe('[(function)regexp]', () => {
       test.each([
-        [ '/./', /./, true ],
-        [ 'new RegExp()', new RegExp(), true ],
-        [ 'RegExp()', RegExp(), true ],
-        [ '5', 5, false ],
-        [ '{}', {}, false ],
-        [ 'null', null, false ],
-        [ 'undefined', undefined, false ],
-        [ 'NaN', NaN, false ],
-        [ 'Infinity', Infinity, false ],
-        [ 'Symbol()', Symbol('q'), false ]
+        ['/./', /./, true],
+        ['new RegExp()', new RegExp(), true],
+        ['RegExp()', RegExp(), true],
+        ['5', 5, false],
+        ['{}', {}, false],
+        ['null', null, false],
+        ['undefined', void 0, false],
+        ['NaN', NaN, false],
+        ['Infinity', Infinity, false],
+        ['Symbol()', Symbol('q'), false]
       ])('has correct return value for %s', (_, value, expected) => {
-        expect(
-          is.regexp(value)
-        ).toBe(expected)
+        expect(is.regexp(value)).toBe(expected)
       })
     })
 
     describe('[(function)number]', () => {
       test.each([
-        [ '5', 5, true ],
-        [ '5.5', 5.5, true ],
-        [ 'NaN', NaN, false ],
-        [ 'Infinity', Infinity, false ],
-        [ 'Symbol()', Symbol('q'), false ],
-        [ '{}', {}, false ],
-        [ 'null', null, false ],
-        [ 'undefined', undefined, false ]
+        ['5', 5, true],
+        ['5.5', 5.5, true],
+        ['NaN', NaN, false],
+        ['Infinity', Infinity, false],
+        ['Symbol()', Symbol('q'), false],
+        ['{}', {}, false],
+        ['null', null, false],
+        ['undefined', void 0, false]
       ])('has correct return value for %s', (_, value, expected) => {
-        expect(
-          is.number(value)
-        ).toBe(expected)
+        expect(is.number(value)).toBe(expected)
       })
     })
   })