quasar 2.15.2 → 2.15.3

package/src/utils/private.focus/focusout.test.js

@@ -0,0 +1,114 @@
+import { describe, test, expect, vi, afterEach } from 'vitest'
+
+import { addFocusout, removeFocusout } from './focusout.js'
+
+let fnList = []
+
+afterEach(() => {
+  fnList.forEach(fn => {
+    removeFocusout(fn)
+  })
+
+  fnList = []
+})
+
+function createTestFn () {
+  const fn = vi.fn()
+  fnList.push(fn)
+  return fn
+}
+
+function triggerEvt (name = 'focusin') {
+  const evt = new Event(name)
+  document.body.dispatchEvent(evt)
+
+  return evt
+}
+
+describe('[focusout API]', () => {
+  describe('[Functions]', () => {
+    describe('[(function)addFocusout]', () => {
+      test('registers correctly', async () => {
+        const fn = createTestFn()
+
+        expect(
+          addFocusout(fn)
+        ).toBeUndefined()
+
+        expect(fn).not.toHaveBeenCalled()
+
+        const evt = triggerEvt()
+
+        expect(fn).toHaveBeenCalledTimes(1)
+        expect(fn).toHaveBeenCalledWith(evt)
+      })
+
+      test('calls only last registered fn', async () => {
+        const fnFirst = createTestFn()
+        const fnLast = createTestFn()
+
+        expect(
+          addFocusout(fnFirst)
+        ).toBeUndefined()
+
+        expect(
+          addFocusout(fnLast)
+        ).toBeUndefined()
+
+        expect(fnFirst).not.toHaveBeenCalled()
+        expect(fnLast).not.toHaveBeenCalled()
+
+        const evt = triggerEvt()
+
+        expect(fnFirst).not.toHaveBeenCalled()
+        expect(fnLast).toHaveBeenCalledTimes(1)
+        expect(fnLast).toHaveBeenCalledWith(evt)
+
+        removeFocusout(fnLast)
+
+        const evtSecond = triggerEvt()
+
+        expect(fnFirst).toHaveBeenCalledTimes(1)
+        expect(fnFirst).toHaveBeenCalledWith(evtSecond)
+      })
+
+      test('triggers only on focusin evt', () => {
+        const fn = createTestFn()
+
+        expect(
+          addFocusout(fn)
+        ).toBeUndefined()
+
+        expect(fn).not.toHaveBeenCalled()
+
+        triggerEvt('focusout')
+
+        expect(fn).not.toHaveBeenCalled()
+      })
+    })
+
+    describe('[(function)removeFocusout]', () => {
+      test('has correct return value', () => {
+        const fn = createTestFn()
+
+        addFocusout(fn)
+
+        expect(
+          removeFocusout(fn)
+        ).toBeUndefined()
+
+        triggerEvt()
+
+        expect(fn).not.toHaveBeenCalled()
+      })
+
+      test('does not error out if fn is not registered', () => {
+        const fn = createTestFn()
+
+        expect(
+          removeFocusout(fn)
+        ).toBeUndefined()
+      })
+    })
+  })
+})

package/src/utils/private.get-emits-object/get-emits-object.test.js

@@ -0,0 +1,29 @@
+import { describe, test, expect } from 'vitest'
+
+import getEmitsObject from './get-emits-object.js'
+
+describe('[getEmitsObject API]', () => {
+  describe('[Functions]', () => {
+    describe('[(function)default]', () => {
+      test('has correct return value', () => {
+        const emitsArray = [ 'foo', 'bar' ]
+        const result = getEmitsObject(emitsArray)
+
+        expect(
+          result
+        ).toStrictEqual({
+          foo: expect.any(Function),
+          bar: expect.any(Function)
+        })
+
+        expect(
+          result.foo()
+        ).toBe(true)
+
+        expect(
+          result.bar()
+        ).toBe(true)
+      })
+    })
+  })
+})

package/src/utils/private.global/global-config.test.js

@@ -0,0 +1,54 @@
+import { describe, test, expect } from 'vitest'
+import { mount, config } from '@vue/test-utils'
+
+import { globalConfig, globalConfigIsFrozen, freezeGlobalConfig } from './global-config.js'
+
+// We override Quasar install so we have a custom $q.config
+const quasarVuePlugin = config.global.plugins.find(entry => entry.name === 'Quasar')
+const { install } = quasarVuePlugin
+
+function mountWithConfig (config) {
+  quasarVuePlugin.install = app => install(app, { config })
+  mount({ template: '<div />' })
+}
+
+describe('[globalConfig API]', () => {
+  describe('[Variables]', () => {
+    describe('[(variable)globalConfig]', () => {
+      test('is defined correctly', () => {
+        expect(globalConfig).toBeTypeOf('object')
+        expect(Object.keys(globalConfig)).toHaveLength(0)
+        expect(globalConfigIsFrozen).toBe(false)
+
+        const cfg = { some: 'value' }
+        mountWithConfig(cfg)
+
+        expect(globalConfig).toStrictEqual(cfg)
+        expect(globalConfigIsFrozen).toBe(true)
+
+        const secondCfg = { other: 'val' }
+        mountWithConfig(secondCfg)
+
+        expect(globalConfig).toStrictEqual(cfg)
+      })
+    })
+
+    describe('[(variable)globalConfigIsFrozen]', () => {
+      test('is defined correctly', () => {
+        expect(globalConfigIsFrozen).toBeTypeOf('boolean')
+      })
+    })
+  })
+
+  describe('[Functions]', () => {
+    describe('[(function)freezeGlobalConfig]', () => {
+      test('has correct return value', () => {
+        expect(
+          freezeGlobalConfig()
+        ).toBeUndefined()
+
+        expect(globalConfigIsFrozen).toBe(true)
+      })
+    })
+  })
+})

package/src/utils/{private → private.global}/global-dialog.js

@@ -1,7 +1,7 @@
 import { h, ref, nextTick } from 'vue'
 
 import { createChildApp } from '../../install-quasar.js'
-import { createGlobalNode, removeGlobalNode } from './global-nodes.js'
+import { createGlobalNode, removeGlobalNode } from '../private.global/global-nodes.js'
 
 const ssrAPI = {
   onOk: () => ssrAPI,

package/src/utils/{private → private.global}/global-dialog.json

@@ -48,7 +48,7 @@
                   }
                 },
                 "returns": null,
-                "examples": [ "() => console.log('OK!')", "(payload) => Notify.create({ type: 'positive', message: `Successfully saved '${payload.book.name}' book!` })" ]
+                "examples": [ "() => console.log('OK!')", "payload => Notify.create({ type: 'positive', message: `Successfully saved '${payload.book.name}' book!` })" ]
               }
             },
             "returns": {

package/src/utils/{private → private.global}/global-nodes.js

@@ -1,4 +1,4 @@
-import { globalConfig } from './global-config.js'
+import { globalConfig } from '../private.global/global-config.js'
 
 const nodesList = []
 const portalTypeList = []

package/src/utils/private.global/global-nodes.test.js

@@ -0,0 +1,110 @@
+import { describe, test, expect, afterEach } from 'vitest'
+
+import { createGlobalNode, removeGlobalNode, changeGlobalNodesTarget } from './global-nodes.js'
+import { globalConfig } from './global-config.js'
+
+let el = null
+
+afterEach(() => {
+  delete globalConfig.globalNodes
+
+  if (el !== null) {
+    removeGlobalNode(el)
+    el = null
+  }
+})
+
+describe('[globalNodes API]', () => {
+  describe('[Functions]', () => {
+    describe('[(function)createGlobalNode]', () => {
+      test('createGlobalNode(id)', () => {
+        const el = createGlobalNode('first')
+
+        expect(el).toBeInstanceOf(Element)
+        expect(el.getAttribute('id')).toBe('first')
+        expect(el.getAttribute('class')).toBeNull()
+        expect(el.parentNode).toBe(document.body)
+      })
+
+      test('createGlobalNode(id) + globalNodes.class', () => {
+        globalConfig.globalNodes = { class: 'some-class' }
+
+        const el = createGlobalNode('some-id')
+
+        expect(el).toBeInstanceOf(Element)
+        expect(el.getAttribute('id')).toBe('some-id')
+        expect(el.getAttribute('class')).toBe('some-class')
+        expect(el.parentNode).toBe(document.body)
+      })
+
+      test('createGlobalNode(id, portalType)', () => {
+        const el = createGlobalNode('port1', 'portType')
+
+        expect(el).toBeInstanceOf(Element)
+        expect(el.getAttribute('id')).toMatch(/^q-portal--portType--\d+$/)
+        expect(el.getAttribute('class')).toBeNull()
+        expect(el.parentNode).toBe(document.body)
+      })
+
+      test('createGlobalNode(id, portalType) + globalNodes.class', () => {
+        globalConfig.globalNodes = { class: 'port-class' }
+
+        const el = createGlobalNode('port1', 'portType')
+
+        expect(el).toBeInstanceOf(Element)
+        expect(el.getAttribute('id')).toMatch(/^q-portal--portType--\d+$/)
+        expect(el.getAttribute('class')).toBe('port-class')
+        expect(el.parentNode).toBe(document.body)
+      })
+    })
+
+    describe('[(function)removeGlobalNode]', () => {
+      test('has correct return value', () => {
+        const el = createGlobalNode('rem')
+
+        expect(
+          removeGlobalNode(el)
+        ).toBeUndefined()
+
+        expect(el.parentNode).toBeNull()
+      })
+
+      test('does not error out when removing non-existing el', () => {
+        const localEl = document.createElement('div')
+        expect(
+          removeGlobalNode(localEl)
+        ).toBeUndefined()
+      })
+    })
+
+    describe('[(function)changeGlobalNodesTarget]', () => {
+      test('has correct return value', () => {
+        const elList = [
+          createGlobalNode('node1'),
+          createGlobalNode('node2'),
+          createGlobalNode('node3', 'ptype')
+        ]
+
+        elList.forEach(node => {
+          expect(
+            node.parentElement === document.body
+          ).toBe(true)
+        })
+
+        const newTargetEl = document.createElement('div')
+        newTargetEl.setAttribute('id', 'new-target')
+        document.body.appendChild(newTargetEl)
+
+        expect(
+          changeGlobalNodesTarget(newTargetEl)
+        ).toBeUndefined()
+
+        elList.forEach(node => {
+          expect(
+            node.parentElement
+          ).toBe(newTargetEl)
+        })
+      })
+    })
+  })
+})

package/src/utils/private.inject-obj-prop/inject-obj-prop.test.js

@@ -0,0 +1,104 @@
+import { describe, test, expect } from 'vitest'
+
+import { injectProp, injectMultipleProps } from './inject-obj-prop.js'
+
+describe('[injectObjProp API]', () => {
+  describe('[Functions]', () => {
+    describe('[(function)injectProp]', () => {
+      test('attaches getter correctly', () => {
+        const source = { a: 5 }
+        const target = {}
+
+        const result = injectProp(
+          target,
+          'prop',
+          () => source.a
+        )
+
+        expect(
+          result
+        ).toBe(target)
+
+        expect(
+          result.prop
+        ).toBe(source.a)
+
+        source.a = 'str'
+
+        expect(
+          result.prop
+        ).toBe(source.a)
+      })
+
+      test('attaches getter + setter correctly', () => {
+        const source = { a: 5 }
+        const target = {}
+
+        const result = injectProp(
+          target,
+          'prop',
+          () => source.a,
+          val => { source.a = val }
+        )
+
+        expect(
+          result
+        ).toBe(target)
+
+        expect(
+          result.prop
+        ).toBe(source.a)
+
+        source.a = 'str'
+
+        expect(
+          result.prop
+        ).toBe(source.a)
+
+        result.prop = 10
+
+        expect(
+          result.prop
+        ).toBe(source.a)
+      })
+    })
+
+    describe('[(function)injectMultipleProps]', () => {
+      test('attaches multiple props with getters', () => {
+        const source = { a: 5, b: 'str' }
+        const target = {}
+
+        const result = injectMultipleProps(
+          target,
+          {
+            propA: () => source.a,
+            propB: () => source.b
+          }
+        )
+
+        expect(
+          result
+        ).toBe(target)
+
+        expect(
+          result.propA
+        ).toBe(source.a)
+
+        expect(
+          result.propB
+        ).toBe(source.b)
+
+        source.a = 'str'
+        source.b = 10
+
+        expect(
+          result.propA
+        ).toBe(source.a)
+
+        expect(
+          result.propB
+        ).toBe(source.b)
+      })
+    })
+  })
+})

package/src/utils/{private → private.keyboard}/escape-key.js

@@ -1,5 +1,5 @@
 import { client } from '../../plugins/platform/Platform.js'
-import { isKeyCode } from './key-composition.js'
+import { isKeyCode } from '../private.keyboard/key-composition.js'
 
 const handlers = []
 let escDown

package/src/utils/private.keyboard/escape-key.test.js

@@ -0,0 +1,117 @@
+import { describe, test, expect, vi, afterEach } from 'vitest'
+
+import { addEscapeKey, removeEscapeKey } from './escape-key.js'
+
+let fnList = []
+
+afterEach(() => {
+  fnList.forEach(fn => {
+    removeEscapeKey(fn)
+  })
+
+  fnList = []
+})
+
+function createTestFn () {
+  const fn = vi.fn()
+  fnList.push(fn)
+  return fn
+}
+
+function triggerKey (keyCode = 27) {
+  const keydown = new KeyboardEvent('keydown', { keyCode })
+  window.dispatchEvent(keydown)
+
+  const keyup = new KeyboardEvent('keyup', { keyCode })
+  window.dispatchEvent(keyup)
+
+  return keyup
+}
+
+describe('[escapeKey API]', () => {
+  describe('[Functions]', () => {
+    describe('[(function)addEscapeKey]', () => {
+      test('registers correctly', async () => {
+        const fn = createTestFn()
+
+        expect(
+          addEscapeKey(fn)
+        ).toBeUndefined()
+
+        expect(fn).not.toHaveBeenCalled()
+
+        const evt = triggerKey()
+
+        expect(fn).toHaveBeenCalledTimes(1)
+        expect(fn).toHaveBeenCalledWith(evt)
+      })
+
+      test('calls only last registered fn', async () => {
+        const fnFirst = createTestFn()
+        const fnLast = createTestFn()
+
+        expect(
+          addEscapeKey(fnFirst)
+        ).toBeUndefined()
+
+        expect(
+          addEscapeKey(fnLast)
+        ).toBeUndefined()
+
+        expect(fnFirst).not.toHaveBeenCalled()
+        expect(fnLast).not.toHaveBeenCalled()
+
+        const evt = triggerKey()
+
+        expect(fnFirst).not.toHaveBeenCalled()
+        expect(fnLast).toHaveBeenCalledTimes(1)
+        expect(fnLast).toHaveBeenCalledWith(evt)
+
+        removeEscapeKey(fnLast)
+
+        const evtSecond = triggerKey()
+
+        expect(fnFirst).toHaveBeenCalledTimes(1)
+        expect(fnFirst).toHaveBeenCalledWith(evtSecond)
+      })
+
+      test('triggers only on ESC key', () => {
+        const fn = createTestFn()
+
+        expect(
+          addEscapeKey(fn)
+        ).toBeUndefined()
+
+        expect(fn).not.toHaveBeenCalled()
+
+        triggerKey(65)
+
+        expect(fn).not.toHaveBeenCalled()
+      })
+    })
+
+    describe('[(function)removeEscapeKey]', () => {
+      test('has correct return value', () => {
+        const fn = createTestFn()
+
+        addEscapeKey(fn)
+
+        expect(
+          removeEscapeKey(fn)
+        ).toBeUndefined()
+
+        triggerKey()
+
+        expect(fn).not.toHaveBeenCalled()
+      })
+
+      test('does not error out if fn is not registered', () => {
+        const fn = createTestFn()
+
+        expect(
+          removeEscapeKey(fn)
+        ).toBeUndefined()
+      })
+    })
+  })
+})

package/src/utils/private.noop-ssr-directive-transform/noop-ssr-directive-transform.test.js

@@ -0,0 +1,14 @@
+import { describe, test, expect } from 'vitest'
+
+import noopSsrDirectiveTransform from './noop-ssr-directive-transform.js'
+
+describe('[noopSsrDirectiveTransform API]', () => {
+  describe('[Functions]', () => {
+    describe('[(function)default]', () => {
+      test('has correct return value', () => {
+        const result = noopSsrDirectiveTransform()
+        expect(result).toStrictEqual({})
+      })
+    })
+  })
+})

package/src/utils/{private → private.portal}/portal.js

@@ -1,4 +1,4 @@
-import { getParentProxy } from './vm.js'
+import { getParentProxy } from '../private.vm/vm.js'
 
 export const portalProxyList = []
 

package/src/utils/{private → private.position-engine}/position-engine.js

@@ -1,4 +1,4 @@
-import { getScrollbarWidth } from '../scroll.js'
+import { getScrollbarWidth } from '../scroll/scroll.js'
 import { client } from '../../plugins/platform/Platform.js'
 
 let vpLeft, vpTop

package/src/utils/private.rtl/rtl.test.js

@@ -0,0 +1,13 @@
+import { describe, test, expect } from 'vitest'
+
+import { rtlHasScrollBug } from './rtl.js'
+
+describe('[rtl API]', () => {
+  describe('[Variables]', () => {
+    describe('[(variable)rtlHasScrollBug]', () => {
+      test('is defined correctly', () => {
+        expect(rtlHasScrollBug).toBeTypeOf('boolean')
+      })
+    })
+  })
+})

package/src/utils/private.sort/sort.test.js

@@ -0,0 +1,25 @@
+import { describe, test, expect } from 'vitest'
+
+import { sortDate, sortBoolean } from './sort.js'
+
+describe('[sort API]', () => {
+  describe('[Functions]', () => {
+    describe('[(function)sortDate]', () => {
+      test('has correct return value', () => {
+        const a = new Date(10)
+        const b = new Date()
+        expect(sortDate(a, b)).toBeLessThan(0)
+        expect(sortDate(b, a)).toBeGreaterThan(0)
+        expect(sortDate(a, a)).toBe(0)
+      })
+    })
+
+    describe('[(function)sortBoolean]', () => {
+      test('has correct return value', () => {
+        expect(sortBoolean(false, true)).toBeGreaterThan(0)
+        expect(sortBoolean(true, false)).toBeLessThan(0)
+        expect(sortBoolean(true, true)).toBe(0)
+      })
+    })
+  })
+})

package/src/utils/{private → private.symbols}/symbols.js

@@ -8,4 +8,4 @@ export const formKey = '_q_fo_'
 export const tabsKey = '_q_tabs_'
 export const uploaderKey = '_q_u_'
 
-export const emptyRenderFn = () => {}
+export function emptyRenderFn () {}