quasar 2.15.2 → 2.15.4

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/dom/dom.test.js

@@ -0,0 +1,222 @@
+import { describe, test, expect, vi, onTestFinished } from 'vitest'
+import { ref } from 'vue'
+
+import dom, { getElement, childHasFocus } from './dom.js'
+
+function createEl ({ top, left } = {}) {
+  const el = document.createElement('div')
+  el.setAttribute('tabindex', '0')
+  el.classList = 'fixed'
+
+  if (top !== void 0) {
+    el.style.top = top
+  }
+  if (left !== void 0) {
+    el.style.left = left
+  }
+
+  document.body.appendChild(el)
+  onTestFinished(() => { el.remove() })
+
+  return el
+}
+
+describe('[dom API]', () => {
+  describe('[Functions]', () => {
+    describe('[(function)offset]', () => {
+      test('has correct return value', () => {
+        const el = createEl()
+
+        expect(
+          dom.offset(el)
+        ).toStrictEqual({
+          top: expect.any(Number),
+          left: expect.any(Number)
+        })
+      })
+    })
+
+    describe('[(function)style]', () => {
+      test('has correct return value', () => {
+        const el = createEl({ top: '10px', left: '20px' })
+
+        expect(
+          dom.style(el, 'top')
+        ).toBe('10px')
+
+        expect(
+          dom.style(el, 'left')
+        ).toBe('20px')
+      })
+    })
+
+    describe('[(function)height]', () => {
+      test('height()', () => {
+        window.innerHeight = 100
+        expect(dom.height(window)).toBe(100)
+      })
+
+      test('height(el)', () => {
+        const el = createEl()
+        el.style.height = '100px'
+
+        expect(
+          dom.height(el)
+        ).toBeTypeOf('number')
+      })
+    })
+
+    describe('[(function)width]', () => {
+      test('width()', () => {
+        window.innerHeight = 100
+        expect(dom.height(window)).toBe(100)
+      })
+
+      test('width(el)', () => {
+        const el = createEl()
+        el.style.width = '100px'
+
+        expect(
+          dom.width(el)
+        ).toBeTypeOf('number')
+      })
+    })
+
+    describe('[(function)css]', () => {
+      test('has correct return value', () => {
+        const el = createEl()
+
+        const result = dom.css(el, {
+          width: '54px',
+          height: '154px'
+        })
+
+        expect(result).toBeUndefined()
+        expect(el.style.width).toBe('54px')
+        expect(el.style.height).toBe('154px')
+      })
+    })
+
+    describe('[(function)cssBatch]', () => {
+      test('has correct return value', () => {
+        const el1 = createEl()
+        const el2 = createEl()
+
+        const result = dom.cssBatch([ el1, el2 ], {
+          width: '54px',
+          height: '154px'
+        })
+
+        expect(result).toBeUndefined()
+
+        expect(el1.style.width).toBe('54px')
+        expect(el1.style.height).toBe('154px')
+
+        expect(el2.style.width).toBe('54px')
+        expect(el2.style.height).toBe('154px')
+      })
+    })
+
+    describe('[(function)ready]', () => {
+      test('ready()', () => {
+        expect(
+          dom.ready()
+        ).toBeUndefined()
+      })
+
+      test('ready(5)', () => {
+        expect(
+          dom.ready(5)
+        ).toBeUndefined()
+      })
+
+      test('ready(fn)', () => {
+        const fn = vi.fn(() => 5)
+
+        expect(
+          dom.ready(fn)
+        ).toBe(5)
+      })
+    })
+
+    describe('[(function)getElement]', () => {
+      test('getElement()', () => {
+        expect(getElement()).toBeUndefined()
+      })
+
+      test('getElement(null)', () => {
+        expect(getElement(null)).toBeUndefined()
+      })
+
+      test('getElement(el)', () => {
+        const el = createEl()
+        el.setAttribute('id', 'test-el')
+
+        expect(getElement('#test-el')).toBe(el)
+        expect(getElement('#bogus')).toBeUndefined()
+      })
+
+      test('getElement(vnode)', () => {
+        const el = createEl()
+        const vnode = { $el: el }
+
+        expect(getElement(vnode)).toBe(el)
+      })
+
+      test('getElement(ref)', () => {
+        const el = createEl()
+        const elRef = ref(el)
+
+        expect(getElement(elRef)).toBe(el)
+      })
+    })
+
+    describe('[(function)childHasFocus]', () => {
+      test('childHasFocus()', () => {
+        expect(childHasFocus()).toBe(true)
+      })
+
+      test('childHasFocus(null)', () => {
+        expect(childHasFocus(null)).toBe(true)
+      })
+
+      test('childHasFocus(el, elChild)', () => {
+        const el = createEl()
+        const elChild = document.createElement('div')
+        el.appendChild(elChild)
+
+        expect(
+          childHasFocus(el, elChild)
+        ).toBe(true)
+      })
+
+      test('childHasFocus(el, parentEl)', () => {
+        const parentEl = createEl()
+        const el = document.createElement('div')
+
+        expect(
+          childHasFocus(el, parentEl)
+        ).toBe(false)
+      })
+
+      test('childHasFocus(el, nextSiblingEl)', () => {
+        const el = createEl()
+        /* intermediateEl */ createEl()
+        const nextSiblingEl = createEl()
+
+        expect(
+          childHasFocus(el, nextSiblingEl)
+        ).toBe(true)
+      })
+
+      test('childHasFocus(el, prevSiblingEl)', () => {
+        const prevSiblingEl = createEl()
+        const el = createEl()
+
+        expect(
+          childHasFocus(el, prevSiblingEl)
+        ).toBe(false)
+      })
+    })
+  })
+})

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