quasar 2.15.1 → 2.15.3

package/src/utils/{create-uploader-component.js → create-uploader-component/create-uploader-component.js}

@@ -1,8 +1,8 @@
-import { coreProps, coreEmits, getRenderer } from '../components/uploader/uploader-core.js'
+import { coreProps, coreEmits, getRenderer } from '../../components/uploader/uploader-core.js'
 
-import { createComponent } from './private/create.js'
-import getEmitsObject from './private/get-emits-object.js'
-import { isObject } from './is.js'
+import { createComponent } from '../private.create/create.js'
+import getEmitsObject from '../private.get-emits-object/get-emits-object.js'
+import { isObject } from '../is/is.js'
 
 const coreEmitsObject = getEmitsObject(coreEmits)
 

package/src/utils/css-var/get-css-var.test.js

@@ -0,0 +1,32 @@
+import { describe, test, expect } from 'vitest'
+
+import getCssVar from './get-css-var.js'
+
+describe('[getCssVar API]', () => {
+  describe('[Functions]', () => {
+    describe('[(function)default]', () => {
+      test('getCssVar(prop)', () => {
+        document.body.style.setProperty(
+          '--q-prop',
+          'my-value'
+        )
+
+        expect(
+          getCssVar('prop')
+        ).toBe('my-value')
+      })
+
+      test('getCssVar(prop, el)', () => {
+        const el = document.createElement('div')
+        document.body.appendChild(el)
+        el.style.setProperty('--q-my-prop', 'some-value')
+
+        expect.soft(
+          getCssVar('my-prop', el)
+        ).toBe('some-value')
+
+        el.remove()
+      })
+    })
+  })
+})

package/src/utils/css-var/set-css-var.test.js

@@ -0,0 +1,36 @@
+import { describe, test, expect } from 'vitest'
+
+import setCssVar from './set-css-var.js'
+
+describe('[setCssVar API]', () => {
+  describe('[Functions]', () => {
+    describe('[(function)default]', () => {
+      test('setCss(prop)', () => {
+        expect(
+          setCssVar('prop', 'awesome')
+        ).toBeUndefined()
+
+        expect(
+          getComputedStyle(document.body)
+            .getPropertyValue('--q-prop')
+        ).toBe('awesome')
+      })
+
+      test('setCss(prop, el)', () => {
+        const el = document.createElement('div')
+        document.body.appendChild(el)
+
+        expect.soft(
+          setCssVar('my-prop', 'cool', el)
+        ).toBeUndefined()
+
+        expect.soft(
+          getComputedStyle(el)
+            .getPropertyValue('--q-my-prop')
+        ).toBe('cool')
+
+        el.remove()
+      })
+    })
+  })
+})

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

@@ -1,9 +1,9 @@
 /* eslint no-fallthrough: 0 */
 
-import { isDate } from './is.js'
-import { pad, capitalize } from './format.js'
-import { jalaaliMonthLength } from './private/date-persian.js'
-import lang, { defaultLang } from '../lang.js'
+import { isDate } from '../is/is.js'
+import { pad, capitalize } from '../format/format.js'
+import { jalaaliMonthLength } from './private.persian.js'
+import Lang, { defaultLang } from '../../plugins/lang/Lang.js'
 
 const
   MILLISECONDS_IN_DAY = 86400000,
@@ -352,7 +352,7 @@ export function __splitDate (str, mask, dateLocale, calendar, defaultModel) {
   }
 
   const
-    langOpts = getDateLocale(dateLocale, lang.props),
+    langOpts = getDateLocale(dateLocale, Lang.props),
     months = langOpts.months,
     monthsShort = langOpts.monthsShort
 
@@ -961,7 +961,7 @@ export function formatDate (val, mask, dateLocale, __forcedYear, __forcedTimezon
     mask = defaultMask
   }
 
-  const locale = getDateLocale(dateLocale, lang.props)
+  const locale = getDateLocale(dateLocale, Lang.props)
 
   return mask.replace(
     token,

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()
+      })
+    })
+  })
+})