quasar 2.15.2 → 2.15.3

package/src/utils/debounce/debounce.test.js

@@ -0,0 +1,188 @@
+import {
+  describe, test, expect, vi,
+  beforeEach, afterEach
+} from 'vitest'
+
+import debounce from './debounce.js'
+
+beforeEach(() => {
+  vi.useFakeTimers()
+})
+
+afterEach(() => {
+  vi.clearAllTimers()
+  vi.restoreAllMocks()
+})
+
+describe('[debounce API]', () => {
+  describe('[Functions]', () => {
+    describe('[(function)default]', () => {
+      test('has correct return value', () => {
+        const fn = debounce(() => {}, 1)
+
+        expect(
+          fn
+        ).toBeTypeOf('function')
+
+        expect(
+          fn.cancel
+        ).toBeTypeOf('function')
+      })
+
+      test('should debounce with fast timeout', () => {
+        const callback = vi.fn()
+        const fn = debounce(callback, 100)
+
+        setTimeout(fn, 100)
+        setTimeout(fn, 150)
+        setTimeout(fn, 200)
+        setTimeout(fn, 250)
+
+        vi.advanceTimersByTime(350)
+
+        expect(callback).toHaveBeenCalledTimes(1)
+      })
+
+      test('should not execute prior to timeout', () => {
+        const callback = vi.fn()
+        const fn = debounce(callback, 100)
+
+        setTimeout(fn, 100)
+        setTimeout(fn, 150)
+
+        vi.advanceTimersByTime(175)
+
+        expect(callback).not.toHaveBeenCalled()
+      })
+
+      test('should execute immediately', () => {
+        const callback = vi.fn()
+        const fn = debounce(callback, 100, true)
+
+        fn()
+        fn()
+
+        vi.advanceTimersByTime(150)
+
+        expect(callback).toHaveBeenCalledTimes(1)
+      })
+
+      test('should cancel debounced function', () => {
+        const callback = vi.fn()
+        const fn = debounce(callback, 100)
+
+        fn()
+        fn.cancel()
+        vi.advanceTimersByTime(150)
+
+        expect(callback).not.toHaveBeenCalled()
+      })
+
+      test('should execute with correct args when called again from within timeout', () => {
+        const callback = vi.fn()
+        const fn = debounce(callback, 100)
+
+        fn(1)
+        fn(2)
+        fn(3)
+
+        vi.advanceTimersByTime(150)
+
+        expect(callback).toHaveBeenCalledTimes(1)
+        expect(callback).toHaveBeenCalledWith(3)
+      })
+
+      test('zero wait time', () => {
+        const callback = vi.fn()
+        const fn = debounce(callback, 0)
+
+        fn()
+        fn()
+        fn()
+
+        vi.advanceTimersByTime(1)
+
+        expect(callback).toHaveBeenCalledTimes(1)
+      })
+
+      test('repeated rapid calls', () => {
+        const callback = vi.fn()
+        const fn = debounce(callback, 100)
+
+        fn()
+        fn()
+        fn()
+        fn()
+        fn()
+
+        vi.advanceTimersByTime(150)
+
+        expect(callback).toHaveBeenCalledTimes(1)
+      })
+
+      test('single call', () => {
+        const callback = vi.fn()
+        const fn = debounce(callback, 100)
+
+        fn()
+
+        vi.advanceTimersByTime(150)
+
+        expect(callback).toHaveBeenCalledTimes(1)
+      })
+
+      test('long wait time', () => {
+        const callback = vi.fn()
+        const fn = debounce(callback, 10_000)
+
+        fn()
+        fn()
+
+        vi.advanceTimersByTime(10_000)
+
+        expect(callback).toHaveBeenCalledTimes(1)
+      })
+
+      test('function arguments preservation', () => {
+        const callback = vi.fn()
+        const fn = debounce(callback, 100)
+
+        fn(1, 2, '3')
+
+        vi.advanceTimersByTime(150)
+
+        expect(callback).toHaveBeenCalledTimes(1)
+        expect(callback).toHaveBeenCalledWith(1, 2, '3')
+      })
+
+      test('multiple independent instances', () => {
+        const callback1 = vi.fn()
+        const fn1 = debounce(callback1, 100)
+
+        const callback2 = vi.fn()
+        const fn2 = debounce(callback2, 200)
+
+        fn1()
+        fn2()
+
+        vi.advanceTimersByTime(150)
+
+        expect(callback1).toHaveBeenCalledTimes(1)
+        expect(callback2).toHaveBeenCalledTimes(0)
+
+        vi.advanceTimersByTime(100)
+        expect(callback1).toHaveBeenCalledTimes(1)
+        expect(callback2).toHaveBeenCalledTimes(1)
+      })
+
+      test('no calls made', () => {
+        const callback = vi.fn()
+        debounce(callback, 100)
+
+        vi.runAllTimers()
+
+        expect(callback).not.toHaveBeenCalled()
+      })
+    })
+  })
+})

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

@@ -0,0 +1,93 @@
+import { describe, test, expect } from 'vitest'
+
+import extend from './extend.js'
+
+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' })
+      })
+
+      test('has correct return value', () => {
+        const target = {}
+        const result = extend(target, { a: true, b: 2, c: 'str' })
+        expect(
+          result
+        ).toBe(target)
+      })
+
+      test('extend object (deep)', () => {
+        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 } })
+      })
+
+      test('extend array (deep)', () => {
+        expect(
+          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 ] })
+      })
+
+      test('extend array with object', () => {
+        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 } ]
+      ])('extend %s', (_, 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 })
+      })
+
+      test('extend Fn', () => {
+        const fn1 = () => 5
+        const fn2 = () => 6
+        const result = extend({}, { a: fn1 }, { a: fn2 })
+
+        expect(
+          result
+        ).toStrictEqual({ a: fn2 })
+
+        expect(
+          result.a()
+        ).toBe(6)
+      })
+    })
+  })
+})

package/src/utils/{format.js → format/format.js}

@@ -1,6 +1,6 @@
 const units = [ 'B', 'KB', 'MB', 'GB', 'TB', 'PB' ]
 
-export function humanStorageSize (bytes) {
+export function humanStorageSize (bytes, decimals = 1) {
   let u = 0
 
   while (parseInt(bytes, 10) >= 1024 && u < units.length - 1) {
@@ -8,7 +8,7 @@ export function humanStorageSize (bytes) {
     ++u
   }
 
-  return `${ bytes.toFixed(1) }${ units[ u ] }`
+  return `${ bytes.toFixed(decimals) }${ units[ u ] }`
 }
 
 export function capitalize (str) {

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

@@ -0,0 +1,107 @@
+import { describe, test, expect } from 'vitest'
+
+import format from './format.js'
+
+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 ]
+      ])('handles %s correctly', (expected, value) => {
+        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)
+      })
+    })
+
+    describe('[(function)capitalize]', () => {
+      test('has correct return value', () => {
+        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 ]
+      ])('between(%d, %d, %d)', (value, min, max, 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 ]
+      ])('normalizeToInterval(%d, %d, %d)', (value, min, max, expected) => {
+        expect(
+          format.normalizeToInterval(value, min, max)
+        ).toBe(expected)
+      })
+    })
+
+    describe('[(function)pad]', () => {
+      test.each([
+        [ '1', '01' ],
+        [ '10', '10' ],
+        [ '100', '100' ],
+        [ 'a', '0a' ]
+      ])('pad(%s)', (value, expected) => {
+        expect(
+          format.pad(value)
+        ).toBe(expected)
+      })
+
+      test.each([
+        [ 'A', '00A' ],
+        [ 'A0', '0A0' ],
+        [ 'A00', 'A00' ],
+        [ 'a', '00a' ]
+      ])('pad(%s, 3)', (value, expected) => {
+        expect(
+          format.pad(value, 3)
+        ).toBe(expected)
+      })
+
+      test.each([
+        [ 'A', '-', '--A' ],
+        [ 'A0', '-', '-A0' ],
+        [ 'A00', '*', 'A00' ],
+        [ 'a', '*', '**a' ]
+      ])('pad(%s, 3, %s)', (value, char, expected) => {
+        expect(
+          format.pad(value, 3, char)
+        ).toBe(expected)
+      })
+    })
+  })
+})

package/src/utils/{frame-debounce.js → frame-debounce/frame-debounce.js}

@@ -6,7 +6,7 @@ export default function (fn) {
     if (wait === true) return
 
     wait = true
-    frame = requestAnimationFrame(() => {
+    frame = window.requestAnimationFrame(() => {
       fn.apply(this, callArgs)
       callArgs = void 0
       wait = false

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

@@ -0,0 +1,127 @@
+import {
+  describe, test, expect, vi,
+  beforeEach, afterEach
+} from 'vitest'
+
+import frameDebounce from './frame-debounce.js'
+
+beforeEach(() => {
+  vi.useFakeTimers()
+})
+
+afterEach(() => {
+  vi.clearAllTimers()
+  vi.restoreAllMocks()
+})
+
+describe('[frameDebounce API]', () => {
+  describe('[Functions]', () => {
+    describe('[(function)default]', () => {
+      test('has correct return value', () => {
+        const fn = frameDebounce(() => {})
+
+        expect(
+          fn
+        ).toBeTypeOf('function')
+
+        expect(
+          fn.cancel
+        ).toBeTypeOf('function')
+      })
+
+      test('should debounce with fast timeout', () => {
+        const callback = vi.fn()
+        const fn = frameDebounce(callback)
+
+        setTimeout(fn, 1)
+        setTimeout(fn, 5)
+        setTimeout(fn, 10)
+        setTimeout(fn, 11)
+
+        vi.advanceTimersByTime(17)
+
+        expect(callback).toHaveBeenCalledTimes(1)
+      })
+
+      test('should not execute prior to timeout', () => {
+        const callback = vi.fn()
+        const fn = frameDebounce(callback)
+
+        setTimeout(fn, 1)
+        setTimeout(fn, 5)
+
+        vi.advanceTimersByTime(7)
+        expect(callback).not.toHaveBeenCalled()
+
+        vi.advanceTimersByTime(100)
+        expect(callback).toHaveBeenCalledTimes(1)
+      })
+
+      test('should cancel frame debounced function', () => {
+        const callback = vi.fn()
+        const fn = frameDebounce(callback)
+
+        fn()
+        fn()
+        fn.cancel()
+        vi.advanceTimersByTime(100)
+
+        expect(callback).not.toHaveBeenCalled()
+      })
+
+      test('should execute with correct args when called again from within timeout', () => {
+        const callback = vi.fn()
+        const fn = frameDebounce(callback)
+
+        fn(1)
+        setTimeout(() => fn(1, 2, '3'), 1)
+        vi.advanceTimersByTime(170)
+
+        expect(callback).toHaveBeenCalledWith(1, 2, '3')
+      })
+
+      test('repeated rapid calls', () => {
+        const callback = vi.fn()
+        const fn = frameDebounce(callback)
+
+        fn()
+        fn()
+        fn()
+        fn()
+        fn()
+
+        vi.advanceTimersByTime(100)
+
+        expect(callback).toHaveBeenCalledTimes(1)
+      })
+
+      test('multiple independent instances', () => {
+        const callback1 = vi.fn()
+        const callback2 = vi.fn()
+        const fn1 = frameDebounce(callback1)
+        const fn2 = frameDebounce(callback2)
+
+        fn1()
+        fn1()
+
+        fn2()
+        fn2()
+        fn2()
+
+        vi.advanceTimersByTime(100)
+
+        expect(callback1).toHaveBeenCalledTimes(1)
+        expect(callback2).toHaveBeenCalledTimes(1)
+      })
+
+      test('no calls made', () => {
+        const callback = vi.fn()
+        frameDebounce(callback)
+
+        vi.runAllTimers()
+
+        expect(callback).not.toHaveBeenCalled()
+      })
+    })
+  })
+})

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

@@ -0,0 +1,125 @@
+import { describe, test, expect } from 'vitest'
+
+import is from './is.js'
+
+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 ]) ]
+      ])('deepEqual(%s) matching', (_, a, b) => {
+        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 ]
+      ])('deepEqual(%s)', (_, a, b) => {
+        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 ]
+      ])('has correct return value for %s', (_, value, 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 ]
+      ])('has correct return value for %s', (_, value, 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 ]
+      ])('has correct return value for %s', (_, value, 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 ]
+      ])('has correct return value for %s', (_, value, expected) => {
+        expect(
+          is.number(value)
+        ).toBe(expected)
+      })
+    })
+  })
+})

package/src/utils/{morph.js → morph/morph.js}

@@ -1,4 +1,4 @@
-import { isObject } from './is'
+import { isObject } from '../is/is.js'
 
 let id = 0
 let offsetBase = void 0

package/src/utils/{open-url.js → open-url/open-url.js}

@@ -1,7 +1,7 @@
-import Platform from '../plugins/platform/Platform.js'
+import Platform from '../../plugins/platform/Platform.js'
 
-import { noop } from './event.js'
-import { isNumber } from './is.js'
+import { noop } from '../event/event.js'
+import { isNumber } from '../is/is.js'
 
 function parseFeatures (winFeatures) {
   const cfg = Object.assign({ noopener: true }, winFeatures)