quasar 2.15.3 → 2.16.0

package/src/utils/{private.global/global-config.test.js → private.config/instance-config.test.js}

@@ -1,7 +1,7 @@
 import { describe, test, expect } from 'vitest'
 import { mount, config } from '@vue/test-utils'
 
-import { globalConfig, globalConfigIsFrozen, freezeGlobalConfig } from './global-config.js'
+import { globalConfig, globalConfigIsFrozen, freezeGlobalConfig } from './instance-config.js'
 
 // We override Quasar install so we have a custom $q.config
 const quasarVuePlugin = config.global.plugins.find(entry => entry.name === 'Quasar')
@@ -12,7 +12,7 @@ function mountWithConfig (config) {
   mount({ template: '<div />' })
 }
 
-describe('[globalConfig API]', () => {
+describe('[instanceConfig API]', () => {
   describe('[Variables]', () => {
     describe('[(variable)globalConfig]', () => {
       test('is defined correctly', () => {

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

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

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

@@ -1,7 +1,7 @@
 import { describe, test, expect, afterEach } from 'vitest'
 
-import { createGlobalNode, removeGlobalNode, changeGlobalNodesTarget } from './global-nodes.js'
-import { globalConfig } from './global-config.js'
+import { createGlobalNode, removeGlobalNode, changeGlobalNodesTarget } from './nodes.js'
+import { globalConfig } from './instance-config.js'
 
 let el = null
 
@@ -14,7 +14,7 @@ afterEach(() => {
   }
 })
 
-describe('[globalNodes API]', () => {
+describe('[nodes API]', () => {
   describe('[Functions]', () => {
     describe('[(function)createGlobalNode]', () => {
       test('createGlobalNode(id)', () => {

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

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

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

@@ -0,0 +1,187 @@
+import { describe, test, expect } from 'vitest'
+import { mount, flushPromises } from '@vue/test-utils'
+import { ref } from 'vue'
+
+import { hSlot, hUniqueSlot, hMergeSlot, hMergeSlotSafely, hDir } from './render.js'
+
+describe('[render API]', () => {
+  describe('[Functions]', () => {
+    describe('[(function)hSlot]', () => {
+      test('hSlot()', () => {
+        expect(
+          hSlot()
+        ).toBeUndefined()
+      })
+
+      test('hSlot(void, x)', () => {
+        expect(
+          hSlot(void 0, 'x')
+        ).toBe('x')
+      })
+
+      test('hSlot(() => void, x)', () => {
+        expect(
+          hSlot(() => {}, 'x')
+        ).toBe('x')
+      })
+
+      test('hSlot(() => null, x)', () => {
+        expect(
+          hSlot(() => null, 'x')
+        ).toBe('x')
+      })
+
+      test('hSlot(() => z)', () => {
+        expect(
+          hSlot(() => 'z')
+        ).toBe('z')
+      })
+
+      test('hSlot(() => z, x)', () => {
+        expect(
+          hSlot(() => 'z', 'x')
+        ).toBe('z')
+      })
+    })
+
+    describe('[(function)hUniqueSlot]', () => {
+      test('hUniqueSlot()', () => {
+        expect(
+          hUniqueSlot()
+        ).toBeUndefined()
+      })
+
+      test('hUniqueSlot(void, x)', () => {
+        expect(
+          hUniqueSlot(void 0, 'x')
+        ).toBe('x')
+      })
+
+      test('hUniqueSlot(() => [z])', () => {
+        const value = [ 'z' ]
+        const result = hUniqueSlot(() => value)
+        expect(result).not.toBe(value)
+        expect(result).toStrictEqual([ 'z' ])
+      })
+
+      test('hUniqueSlot(() => [z], x)', () => {
+        const value = [ 'z' ]
+        const result = hUniqueSlot(() => value, 'x')
+        expect(result).not.toBe(value)
+        expect(result).toStrictEqual([ 'z' ])
+      })
+
+      test('hUniqueSlot(() => void, x)', () => {
+        expect(
+          hUniqueSlot(() => {}, 'x')
+        ).toBe('x')
+      })
+
+      test('hUniqueSlot(() => null, x)', () => {
+        expect(
+          hUniqueSlot(() => null, 'x')
+        ).toBe('x')
+      })
+    })
+
+    describe('[(function)hMergeSlot]', () => {
+      test('hMergeSlot(void, [x])', () => {
+        const source = [ 'x' ]
+        const result = hMergeSlot(void 0, source)
+        expect(result).toBe(source)
+      })
+
+      test('hMergeSlot(() => z, [x])', () => {
+        const source = [ 'x' ]
+        const result = hMergeSlot(() => 'z', source)
+        expect(result).not.toBe(source)
+        expect(result).toStrictEqual([ 'x', 'z' ])
+      })
+
+      test('hMergeSlot(() => [z], [x])', () => {
+        const source = [ 'x' ]
+        const result = hMergeSlot(() => [ 'z' ], source)
+        expect(result).not.toBe(source)
+        expect(result).toStrictEqual([ 'x', 'z' ])
+      })
+    })
+
+    describe('[(function)hMergeSlotSafely]', () => {
+      test('hMergeSlotSafely()', () => {
+        expect(hMergeSlot()).toBeUndefined()
+      })
+
+      test('hMergeSlotSafely(void, [x])', () => {
+        const source = [ 'x' ]
+        const result = hMergeSlotSafely(void 0, source)
+        expect(result).toBe(source)
+      })
+
+      test('hMergeSlotSafely(() => z, [x])', () => {
+        const source = [ 'x' ]
+        const result = hMergeSlotSafely(() => 'z', source)
+        expect(result).not.toBe(source)
+        expect(result).toStrictEqual([ 'x', 'z' ])
+      })
+
+      test('hMergeSlotSafely(() => [z], [x])', () => {
+        const source = [ 'x' ]
+        const z = [ 'z' ]
+        const result = hMergeSlotSafely(() => z, source)
+        expect(result).not.toBe(source)
+        expect(result).not.toBe(z)
+        expect(result).toStrictEqual([ 'x', 'z' ])
+      })
+
+      test('hMergeSlotSafely(() => [z])', () => {
+        const z = [ 'z' ]
+        const result = hMergeSlotSafely(() => z)
+        expect(result).toBe(z)
+      })
+    })
+
+    describe('[(function)hDir]', () => {
+      test('correctly mounts/unmounts directive', async () => {
+        let directiveIsMounted = false
+        const condition = ref(true)
+
+        const directive = {
+          name: 'custom-directive',
+          beforeMount () {
+            directiveIsMounted = true
+          },
+          beforeUnmount () {
+            directiveIsMounted = false
+          }
+        }
+
+        const wrapper = mount({
+          setup: () => {
+            return () => hDir(
+              'div',
+              { class: 'div-class' },
+              [ 'child' ],
+              'key',
+              condition.value,
+              () => [ [ directive ] ]
+            )
+          }
+        })
+
+        expect(directiveIsMounted).toBe(true)
+        expect(wrapper.html()).toBe('<div class="div-class">child</div>')
+
+        condition.value = false
+        await flushPromises()
+
+        expect(directiveIsMounted).toBe(false)
+        expect(wrapper.html()).toBe('<div class="div-class">child</div>')
+
+        condition.value = true
+        await flushPromises()
+        expect(directiveIsMounted).toBe(true)
+        expect(wrapper.html()).toBe('<div class="div-class">child</div>')
+      })
+    })
+  })
+})

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

@@ -0,0 +1,40 @@
+import { describe, test, expect, onTestFinished } from 'vitest'
+
+import { clearSelection } from './selection.js'
+
+describe('[selection API]', () => {
+  describe('[Functions]', () => {
+    describe('[(function)clearSelection]', () => {
+      test('has correct return value', () => {
+        expect(
+          clearSelection()
+        ).toBeUndefined()
+      })
+
+      test('works correctly', () => {
+        const selection = window.getSelection()
+
+        const el = document.createElement('div')
+        el.innerHTML = '<address>quasar@email.com</address>'
+
+        document.body.appendChild(el)
+
+        onTestFinished(() => { el.remove() })
+
+        selection.selectAllChildren(el)
+
+        expect(
+          selection.toString()
+        ).toBe('quasar@email.com')
+
+        expect(
+          clearSelection()
+        ).toBeUndefined()
+
+        expect(
+          selection.toString()
+        ).toBe('')
+      })
+    })
+  })
+})

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

@@ -0,0 +1,175 @@
+import { describe, test, expect } from 'vitest'
+import { mount, flushPromises } from '@vue/test-utils'
+import { h, getCurrentInstance } from 'vue'
+
+import { getParentProxy, getNormalizedVNodes, vmHasRouter, vmIsDestroyed } from './vm.js'
+
+import { getRouter } from 'testing/runtime/router.js'
+
+describe('[vm API]', () => {
+  describe('[Functions]', () => {
+    describe('[(function)getParentProxy]', () => {
+      test('has correct return value', () => {
+        let childVm, parentVm
+
+        const ChildComponent = {
+          template: '<div />',
+          setup () {
+            childVm = getCurrentInstance()
+            return {}
+          }
+        }
+
+        mount({
+          template: '<div> <ChildComponent /> </div>',
+          components: {
+            ChildComponent
+          },
+          setup () {
+            parentVm = getCurrentInstance()
+            return {}
+          }
+        })
+
+        expect(
+          getParentProxy(childVm.proxy)
+        ).toBe(parentVm.proxy)
+      })
+
+      test('handles complex hierarchy', async () => {
+        let childVm, parentVm
+
+        const ChildComponent = {
+          template: '<div />',
+          setup () {
+            childVm = getCurrentInstance()
+            return {}
+          }
+        }
+
+        const IntermediateComponent = {
+          template: '<div> <ChildComponent /> </div>',
+          components: {
+            ChildComponent
+          }
+        }
+
+        mount({
+          template: '<div> <IntermediateComponent /> </div>',
+          components: {
+            IntermediateComponent
+          },
+          setup () {
+            parentVm = getCurrentInstance()
+            return {}
+          }
+        })
+
+        await flushPromises()
+
+        expect(
+          getParentProxy(
+            getParentProxy(childVm.proxy)
+          )
+        ).toBe(parentVm.proxy)
+      })
+    })
+
+    describe('[(function)getNormalizedVNodes]', () => {
+      test('has correct return value', () => {
+        let vnodes
+
+        const ParentComponent = {
+          setup (_, { slots }) {
+            return () => {
+              vnodes = getNormalizedVNodes(slots.default())
+              return h('div', {}, vnodes)
+            }
+          }
+        }
+
+        const ChildComponent = {
+          template: `
+            <div>
+              <div>Simple</div>
+              <div v-for="n in 2" :key="n">Child {{ n }}</div>
+            </div>
+          `
+        }
+
+        mount({
+          template: `
+            <ParentComponent>
+              <ChildComponent />
+              <ChildComponent v-for="n in 2" :key="n" />
+            </ParentComponent>
+          `,
+          components: {
+            ParentComponent,
+            ChildComponent
+          }
+        })
+
+        expect(vnodes).toBeDefined()
+        expect(vnodes).toHaveLength(3)
+      })
+    })
+
+    describe('[(function)vmHasRouter]', () => {
+      test('returns correctly with no router', () => {
+        let vm
+
+        mount({
+          template: '<div />',
+          setup () {
+            vm = getCurrentInstance()
+            return {}
+          }
+        })
+
+        expect(
+          vmHasRouter(vm)
+        ).toBe(false)
+      })
+
+      test('returns correctly with router', async () => {
+        let vm
+        const router = await getRouter('/route')
+
+        mount({
+          template: '<div />',
+          setup () {
+            vm = getCurrentInstance()
+            return {}
+          }
+        }, {
+          global: {
+            plugins: [ router ]
+          }
+        })
+
+        expect(
+          vmHasRouter(vm)
+        ).toBe(true)
+      })
+    })
+
+    describe('[(function)vmIsDestroyed]', () => {
+      test('has correct return value', () => {
+        let vm
+
+        const wrapper = mount({
+          template: '<div />',
+          setup () {
+            vm = getCurrentInstance()
+            return {}
+          }
+        })
+
+        expect(vmIsDestroyed(vm)).toBe(false)
+        wrapper.unmount()
+        expect(vmIsDestroyed(vm)).toBe(true)
+      })
+    })
+  })
+})

package/src/utils/scroll/scroll.js

@@ -1,5 +1,9 @@
 import { css, getElement } from '../dom/dom.js'
 
+export const scrollTargetProp = __QUASAR_SSR_SERVER__
+  ? {} /* SSR does not know about Element */
+  : [ Element, String ]
+
 const scrollTargets = __QUASAR_SSR_SERVER__
   ? []
   : [ null, document, document.body, document.scrollingElement, document.documentElement ]

package/wrappers/{index.mjs → index.cjs}

@@ -6,39 +6,39 @@
 //  but they are useful only for Quasar CLI projects
 // They are typed via module augmentation by `@quasar/app-webpack` / `@quasar/app-vite`
 
-export function boot (callback) {
+module.exports.boot = function (callback) {
   return callback
 }
 
-export function configure (callback) {
+module.exports.ssrMiddleware = function (callback) {
   return callback
 }
 
-export function preFetch (callback) {
+module.exports.configure = function (callback) {
   return callback
 }
 
-export function route (callback) {
+module.exports.preFetch = function (callback) {
   return callback
 }
 
-export function store (callback) {
+module.exports.route = function (callback) {
   return callback
 }
 
-export function ssrMiddleware (callback) {
+module.exports.store = function (callback) {
   return callback
 }
 
-export function bexBackground (callback) {
+module.exports.bexBackground = function (callback) {
   return callback
 }
 
-export function bexContent (callback) {
+module.exports.bexContent = function (callback) {
   return callback
 }
 
-export function bexDom (callback) {
+module.exports.bexDom = function (callback) {
   return callback
 }
 
@@ -46,7 +46,7 @@ export function bexDom (callback) {
  * Below only for @quasar/app-webpack v3
  */
 
-export function ssrProductionExport (callback) {
+module.exports.ssrProductionExport = function (callback) {
   return callback
 }
 
@@ -54,22 +54,22 @@ export function ssrProductionExport (callback) {
  * Below only for @quasar/app-vite & @quasar/app-webpack v4+
  */
 
-export function ssrCreate (callback) {
+module.exports.ssrCreate = function (callback) {
   return callback
 }
 
-export function ssrListen (callback) {
+module.exports.ssrListen = function (callback) {
   return callback
 }
 
-export function ssrClose (callback) {
+module.exports.ssrClose = function (callback) {
   return callback
 }
 
-export function ssrServeStaticContent (callback) {
+module.exports.ssrServeStaticContent = function (callback) {
   return callback
 }
 
-export function ssrRenderPreloadTag (callback) {
+module.exports.ssrRenderPreloadTag = function (callback) {
   return callback
 }

package/wrappers/index.js

@@ -6,39 +6,39 @@
 //  but they are useful only for Quasar CLI projects
 // They are typed via module augmentation by `@quasar/app-webpack` / `@quasar/app-vite`
 
-module.exports.boot = function (callback) {
+export function boot (callback) {
   return callback
 }
 
-module.exports.ssrMiddleware = function (callback) {
+export function configure (callback) {
   return callback
 }
 
-module.exports.configure = function (callback) {
+export function preFetch (callback) {
   return callback
 }
 
-module.exports.preFetch = function (callback) {
+export function route (callback) {
   return callback
 }
 
-module.exports.route = function (callback) {
+export function store (callback) {
   return callback
 }
 
-module.exports.store = function (callback) {
+export function ssrMiddleware (callback) {
   return callback
 }
 
-module.exports.bexBackground = function (callback) {
+export function bexBackground (callback) {
   return callback
 }
 
-module.exports.bexContent = function (callback) {
+export function bexContent (callback) {
   return callback
 }
 
-module.exports.bexDom = function (callback) {
+export function bexDom (callback) {
   return callback
 }
 
@@ -46,7 +46,7 @@ module.exports.bexDom = function (callback) {
  * Below only for @quasar/app-webpack v3
  */
 
-module.exports.ssrProductionExport = function (callback) {
+export function ssrProductionExport (callback) {
   return callback
 }
 
@@ -54,22 +54,22 @@ module.exports.ssrProductionExport = function (callback) {
  * Below only for @quasar/app-vite & @quasar/app-webpack v4+
  */
 
-module.exports.ssrCreate = function (callback) {
+export function ssrCreate (callback) {
   return callback
 }
 
-module.exports.ssrListen = function (callback) {
+export function ssrListen (callback) {
   return callback
 }
 
-module.exports.ssrClose = function (callback) {
+export function ssrClose (callback) {
   return callback
 }
 
-module.exports.ssrServeStaticContent = function (callback) {
+export function ssrServeStaticContent (callback) {
   return callback
 }
 
-module.exports.ssrRenderPreloadTag = function (callback) {
+export function ssrRenderPreloadTag (callback) {
   return callback
 }