@blueprint-ts/core 4.0.0-beta.9 → 4.0.0

package/tests/service/requests/fetch/FetchResponse.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest'
+import { FetchResponse } from '../../../../src/requests/drivers/fetch/FetchResponse'
+
+describe('FetchResponse', () => {
+  it('exposes response data', async () => {
+    const response = new Response('{"name":"Ada"}', {
+      status: 201,
+      headers: { 'X-Test': 'yes' },
+    })
+
+    const fetchResponse = new FetchResponse(response)
+
+    expect(fetchResponse.getStatusCode()).toBe(201)
+    expect(fetchResponse.getHeaders()).toEqual({
+      'content-type': 'text/plain;charset=UTF-8',
+      'x-test': 'yes',
+    })
+    expect(fetchResponse.getRawResponse()).toBe(response)
+    await expect(fetchResponse.json()).resolves.toEqual({ name: 'Ada' })
+  })
+})

package/tests/service/support/DeferredPromise.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest'
+import { DeferredPromise } from '../../../src/support/DeferredPromise'
+
+describe('DeferredPromise', () => {
+  it('resolves and updates state', async () => {
+    const deferred = new DeferredPromise<string>()
+
+    expect(deferred.state).toBe('pending')
+
+    const resultPromise = deferred.then((value) => `value:${value}`)
+    deferred.resolve('ok')
+
+    await expect(resultPromise).resolves.toBe('value:ok')
+    expect(deferred.state).toBe('fulfilled')
+  })
+
+  it('rejects and updates state', async () => {
+    const deferred = new DeferredPromise<string>()
+
+    const resultPromise = deferred.catch((error) => `error:${String(error)}`)
+    deferred.reject('boom')
+
+    await expect(resultPromise).resolves.toBe('error:boom')
+    expect(deferred.state).toBe('rejected')
+  })
+
+  it('supports finally', async () => {
+    const deferred = new DeferredPromise<string>()
+    let ran = false
+
+    const promise = deferred.finally(() => {
+      ran = true
+    })
+
+    deferred.resolve('ok')
+    await promise
+
+    expect(ran).toBe(true)
+  })
+})

package/tests/service/support/helpers.test.ts

@@ -0,0 +1,37 @@
+import { beforeEach, describe, expect, it } from 'vitest'
+import { getCookie, getDisplayablePages, isAtBottom, isObject } from '../../../src/support/helpers'
+
+describe('support helpers', () => {
+  beforeEach(() => {
+    document.cookie = ''
+  })
+
+  it('reads cookies by name and trims spaces', () => {
+    document.cookie = 'first=one'
+    document.cookie = 'second=two'
+
+    expect(getCookie('first')).toBe('one')
+    expect(getCookie('second')).toBe('two')
+    expect(getCookie('missing')).toBe('')
+  })
+
+  it('detects objects and excludes arrays/null', () => {
+    expect(isObject({})).toBe(true)
+    expect(isObject({ a: 1 })).toBe(true)
+    expect(isObject([])).toBe(false)
+    expect(isObject(null)).toBe(false)
+    expect(isObject(undefined)).toBe(false)
+  })
+
+  it('calculates displayable pages with bounds', () => {
+    expect(getDisplayablePages(3, 1, 4)).toEqual([1, 2, 3])
+    expect(getDisplayablePages(10, 1, 4)).toEqual([1, 2, 3, 4])
+    expect(getDisplayablePages(10, 5, 4)).toEqual([4, 5, 6, 7])
+    expect(getDisplayablePages(10, 10, 4)).toEqual([7, 8, 9, 10])
+  })
+
+  it('detects near-bottom scroll positions', () => {
+    expect(isAtBottom(100, 97, 3)).toBe(true)
+    expect(isAtBottom(100, 90, 3)).toBe(false)
+  })
+})

package/tests/vue/composables/useConfirmDialog.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from 'vitest'
+import { createApp, defineComponent, h } from 'vue'
+import useConfirmDialog, { ConfirmDialogSeverity, type ConfirmDialogOptions } from '../../../src/vue/composables/useConfirmDialog'
+
+const options: ConfirmDialogOptions = {
+  getMessage: () => 'Are you sure?',
+  getSeverity: () => ConfirmDialogSeverity.INFO,
+  getTitle: () => 'Confirm',
+  getOkText: () => 'OK',
+  getCancelText: () => 'Cancel',
+}
+
+describe('useConfirmDialog', () => {
+  it('throws when called outside setup', async () => {
+    const Dialog = defineComponent({ setup: () => () => h('div') })
+    const { openConfirmDialog } = useConfirmDialog(Dialog, '#dialog')
+
+    await expect(openConfirmDialog(options)).rejects.toThrow('useConfirmDialog must be called inside a setup function')
+  })
+
+  it('opens dialog and returns exposed result', async () => {
+    const dialogTarget = document.createElement('div')
+    dialogTarget.id = 'dialog'
+    document.body.appendChild(dialogTarget)
+
+    const Dialog = defineComponent({
+      setup(_, { expose }) {
+        expose({ open: Promise.resolve(true) })
+        return () => h('div')
+      },
+    })
+
+    let openConfirmDialog: (opts: ConfirmDialogOptions) => Promise<boolean>
+
+    const App = defineComponent({
+      setup() {
+        ;({ openConfirmDialog } = useConfirmDialog(Dialog, '#dialog'))
+        return () => h('div')
+      },
+    })
+
+    const root = document.createElement('div')
+    document.body.appendChild(root)
+
+    createApp(App).mount(root)
+
+    await expect(openConfirmDialog(options)).resolves.toBe(true)
+  })
+
+  it('throws when dialog does not expose open', async () => {
+    const dialogTarget = document.createElement('div')
+    dialogTarget.id = 'dialog-2'
+    document.body.appendChild(dialogTarget)
+
+    const Dialog = defineComponent({
+      setup() {
+        return () => h('div')
+      },
+    })
+
+    let openConfirmDialog: (opts: ConfirmDialogOptions) => Promise<boolean>
+
+    const App = defineComponent({
+      setup() {
+        ;({ openConfirmDialog } = useConfirmDialog(Dialog, '#dialog-2'))
+        return () => h('div')
+      },
+    })
+
+    const root = document.createElement('div')
+    document.body.appendChild(root)
+
+    createApp(App).mount(root)
+
+    await expect(openConfirmDialog(options)).rejects.toThrow('Provided component does not expose an "open" method')
+  })
+})

package/tests/vue/composables/useGlobalCheckbox.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, it, vi } from 'vitest'
+import { createApp, defineComponent, h, type Component } from 'vue'
+import useGlobalCheckbox from '../../../src/vue/composables/useGlobalCheckbox'
+
+const setupComposable = <T>(dialog: Component, options: { getAll: () => Promise<T[]>; getPage: () => T[]; totalCount: () => number }, targetId: string) => {
+  const dialogTarget = document.createElement('div')
+  dialogTarget.id = targetId
+  document.body.appendChild(dialogTarget)
+
+  let api: ReturnType<typeof useGlobalCheckbox<T>> | undefined
+
+  const App = defineComponent({
+    setup() {
+      api = useGlobalCheckbox<T>(dialog, options, `#${targetId}`)
+      return () => h('div')
+    },
+  })
+
+  const root = document.createElement('div')
+  document.body.appendChild(root)
+  createApp(App).mount(root)
+
+  return api!
+}
+
+const createEvent = () => {
+  const input = document.createElement('input')
+  const event = new Event('change') as Event & { target: HTMLInputElement; preventDefault: () => void }
+  Object.defineProperty(event, 'target', { value: input })
+  event.preventDefault = vi.fn()
+  return event
+}
+
+describe('useGlobalCheckbox', () => {
+  it('selects current page when all elements are on page', async () => {
+    const Dialog = defineComponent({
+      setup(_, { expose }) {
+        expose({ open: Promise.resolve(true) })
+        return () => h('div')
+      },
+    })
+
+    const options = {
+      getAll: vi.fn().mockResolvedValue([1, 2]),
+      getPage: vi.fn().mockReturnValue([1, 2]),
+      totalCount: vi.fn().mockReturnValue(2),
+    }
+
+    const api = setupComposable<number>(Dialog, options, 'dialog-all')
+
+    await api.handleGlobalCheckboxChange(createEvent())
+
+    expect(api.selectedRows.value).toEqual([1, 2])
+  })
+
+  it('opens dialog to select all when not all elements are on page', async () => {
+    const Dialog = defineComponent({
+      setup(_, { expose }) {
+        expose({ open: Promise.resolve(true) })
+        return () => h('div')
+      },
+    })
+
+    const options = {
+      getAll: vi.fn().mockResolvedValue([1, 2, 3]),
+      getPage: vi.fn().mockReturnValue([1]),
+      totalCount: vi.fn().mockReturnValue(3),
+    }
+
+    const api = setupComposable<number>(Dialog, options, 'dialog-select-all')
+    const event = createEvent()
+
+    await api.handleGlobalCheckboxChange(event)
+
+    expect(event.preventDefault).toHaveBeenCalled()
+    expect(api.selectedRows.value).toEqual([1, 2, 3])
+  })
+
+  it('clears selection on indeterminate cancel', async () => {
+    const Dialog = defineComponent({
+      setup(_, { expose }) {
+        expose({ open: Promise.resolve(false) })
+        return () => h('div')
+      },
+    })
+
+    const options = {
+      getAll: vi.fn().mockResolvedValue([1, 2, 3]),
+      getPage: vi.fn().mockReturnValue([1]),
+      totalCount: vi.fn().mockReturnValue(3),
+    }
+
+    const api = setupComposable<number>(Dialog, options, 'dialog-cancel')
+    api.selectedRows.value = [1]
+
+    await api.handleGlobalCheckboxChange(createEvent())
+
+    expect(api.selectedRows.value).toEqual([])
+  })
+
+  it('clears selection when already checked', async () => {
+    const Dialog = defineComponent({
+      setup(_, { expose }) {
+        expose({ open: Promise.resolve(true) })
+        return () => h('div')
+      },
+    })
+
+    const options = {
+      getAll: vi.fn().mockResolvedValue([1, 2]),
+      getPage: vi.fn().mockReturnValue([1, 2]),
+      totalCount: vi.fn().mockReturnValue(2),
+    }
+
+    const api = setupComposable<number>(Dialog, options, 'dialog-checked')
+    api.selectedRows.value = [1, 2]
+
+    await api.handleGlobalCheckboxChange(createEvent())
+
+    expect(api.selectedRows.value).toEqual([])
+
+    api.selectedRows.value = [1]
+    api.checked.value = false
+    expect(api.selectedRows.value).toEqual([])
+  })
+})

package/tests/vue/composables/useIsEmpty.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest'
+import useIsEmpty from '../../../src/vue/composables/useIsEmpty'
+
+describe('useIsEmpty', () => {
+  it('detects empty values', () => {
+    const { isEmpty, isNotEmpty } = useIsEmpty()
+
+    expect(isEmpty(undefined)).toBe(true)
+    expect(isEmpty(null)).toBe(true)
+    expect(isEmpty('')).toBe(true)
+    expect(isEmpty([])).toBe(true)
+    expect(isEmpty({})).toBe(true)
+
+    expect(isNotEmpty('a')).toBe(true)
+    expect(isNotEmpty([1])).toBe(true)
+    expect(isNotEmpty({ a: 1 })).toBe(true)
+  })
+})

package/tests/vue/composables/useIsOpen.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it, vi } from 'vitest'
+import useIsOpen from '../../../src/vue/composables/useIsOpen'
+
+describe('useIsOpen', () => {
+  it('tracks open state and increments key after delay', () => {
+    vi.useFakeTimers()
+
+    const callback = vi.fn()
+    const { isOpen, isOpenKey } = useIsOpen(callback, 50)
+
+    isOpen.value = true
+    expect(isOpen.value).toBe(true)
+    expect(callback).toHaveBeenCalledWith(true)
+
+    isOpen.value = false
+    expect(isOpen.value).toBe(false)
+    expect(callback).toHaveBeenCalledWith(false)
+
+    expect(isOpenKey.value).toBe(0)
+    vi.advanceTimersByTime(50)
+    expect(isOpenKey.value).toBe(1)
+
+    vi.useRealTimers()
+  })
+})

package/tests/vue/composables/useIsOpenFromVar.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it, vi } from 'vitest'
+import useIsOpenFromVar from '../../../src/vue/composables/useIsOpenFromVar'
+
+describe('useIsOpenFromVar', () => {
+  it('syncs open state with variable and resets after delay', () => {
+    vi.useFakeTimers()
+
+    const { fromVar, isOpenFromVar, isOpenFromVarKey } = useIsOpenFromVar<string>('default', 50)
+
+    fromVar.value = 'value'
+    expect(isOpenFromVar.value).toBe(true)
+    expect(fromVar.value).toBe('value')
+
+    isOpenFromVar.value = false
+    vi.advanceTimersByTime(50)
+
+    expect(fromVar.value).toBe('default')
+    expect(isOpenFromVarKey.value).toBe(1)
+
+    vi.useRealTimers()
+  })
+})

package/tests/vue/composables/useModelWrapper.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it, vi } from 'vitest'
+import useModelWrapper from '../../../src/vue/composables/useModelWrapper'
+
+describe('useModelWrapper', () => {
+  it('wraps modelValue and emits updates', () => {
+    const props = { modelValue: 1 }
+    const emit = vi.fn()
+    const callback = vi.fn()
+
+    const model = useModelWrapper<number, typeof emit>(props, emit, { callback })
+
+    expect(model.value).toBe(1)
+
+    model.value = 2
+
+    expect(emit).toHaveBeenCalledWith('update:modelValue', 2)
+    expect(callback).toHaveBeenCalledWith(2)
+  })
+
+  it('supports custom model name', () => {
+    const props = { custom: 'a' }
+    const emit = vi.fn()
+
+    const model = useModelWrapper<string, typeof emit>(props, emit, { name: 'custom' })
+
+    model.value = 'b'
+
+    expect(emit).toHaveBeenCalledWith('update:custom', 'b')
+  })
+})

package/tests/vue/composables/useOnOpen.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it, vi } from 'vitest'
+import { ref, nextTick } from 'vue'
+import useOnOpen from '../../../src/vue/composables/useOnOpen'
+
+describe('useOnOpen', () => {
+  it('invokes open and close callbacks', async () => {
+    const isOpen = ref(false)
+    const { onOpen, onClose } = useOnOpen(isOpen)
+
+    const openCb = vi.fn()
+    const closeCb = vi.fn()
+
+    onOpen(openCb)
+    onClose(closeCb)
+
+    isOpen.value = true
+    await nextTick()
+    await nextTick()
+    expect(openCb).toHaveBeenCalledTimes(1)
+
+    isOpen.value = false
+    await nextTick()
+    await nextTick()
+    expect(closeCb).toHaveBeenCalledTimes(1)
+  })
+})

package/tests/vue/forms/PropertyAwareArray.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest'
+import { PropertyAwareArray } from '../../../src/vue/forms/PropertyAwareArray'
+
+describe('PropertyAwareArray', () => {
+  it('creates from array and preserves type on map/filter/slice/concat', () => {
+    const arr = new PropertyAwareArray<number>([1, 2, 3])
+
+    const mapped = arr.map((value) => value * 2)
+    const filtered = arr.filter((value) => value > 1)
+    const sliced = arr.slice(1)
+    const concatenated = arr.concat([4])
+
+    expect(mapped).toBeInstanceOf(PropertyAwareArray)
+    expect(filtered).toBeInstanceOf(PropertyAwareArray)
+    expect(sliced).toBeInstanceOf(PropertyAwareArray)
+    expect(concatenated).toBeInstanceOf(PropertyAwareArray)
+
+    expect(mapped).toEqual([2, 4, 6])
+    expect(filtered).toEqual([2, 3])
+    expect(sliced).toEqual([2, 3])
+    expect(concatenated).toEqual([1, 2, 3, 4])
+  })
+
+  it('creates from arrayLike', () => {
+    const from = PropertyAwareArray.from({ 0: 'a', 1: 'b', length: 2 })
+
+    expect(from).toBeInstanceOf(PropertyAwareArray)
+    expect(from).toEqual(['a', 'b'])
+  })
+})

package/tests/vue/forms/validation/ValidationRules.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from 'vitest'
+import { RequiredRule } from '../../../../src/vue/forms/validation/rules/RequiredRule'
+import { EmailRule } from '../../../../src/vue/forms/validation/rules/EmailRule'
+import { MinRule } from '../../../../src/vue/forms/validation/rules/MinRule'
+import { UrlRule } from '../../../../src/vue/forms/validation/rules/UrlRule'
+import { ConfirmedRule } from '../../../../src/vue/forms/validation/rules/ConfirmedRule'
+import { JsonRule } from '../../../../src/vue/forms/validation/rules/JsonRule'
+import { ValidationMode } from '../../../../src/vue/forms/validation/ValidationMode.enum'
+
+describe('Validation rules', () => {
+  it('RequiredRule validates presence', () => {
+    const rule = new RequiredRule()
+
+    expect(rule.validate('')).toBe(false)
+    expect(rule.validate(null as unknown as string)).toBe(false)
+    expect(rule.validate(undefined as unknown as string)).toBe(false)
+    expect(rule.validate(0 as unknown as string)).toBe(true)
+    expect(rule.getMessage()).toBe('This field is required')
+  })
+
+  it('EmailRule validates email format', () => {
+    const rule = new EmailRule()
+
+    expect(rule.validate('')).toBe(true)
+    expect(rule.validate(123)).toBe(false)
+    expect(rule.validate('invalid')).toBe(false)
+    expect(rule.validate('test@example.com')).toBe(true)
+  })
+
+  it('MinRule validates numbers, strings, and arrays', () => {
+    const rule = new MinRule(3)
+
+    expect(rule.validate(null)).toBe(true)
+    expect(rule.validate('ab')).toBe(false)
+    expect(rule.validate('abc')).toBe(true)
+    expect(rule.validate(2)).toBe(false)
+    expect(rule.validate(3)).toBe(true)
+    expect(rule.validate([1, 2])).toBe(false)
+    expect(rule.validate([1, 2, 3])).toBe(true)
+    expect(rule.validate({})).toBe(false)
+    expect(rule.getMessage()).toBe('This field must be at least 3')
+  })
+
+  it('UrlRule validates URLs', () => {
+    const rule = new UrlRule()
+
+    expect(rule.validate('')).toBe(false)
+    expect(rule.validate('not a url')).toBe(false)
+    expect(rule.validate('https://example.com')).toBe(true)
+  })
+
+  it('ConfirmedRule validates matching fields', () => {
+    const rule = new ConfirmedRule<{ password: string; confirm: string }>('confirm')
+
+    expect(rule.dependsOn).toEqual(['confirm'])
+    expect(rule.getBidirectionalFields()).toEqual(['confirm'])
+
+    expect(rule.validate('', { password: '', confirm: '' })).toBe(true)
+    expect(rule.validate('a', { password: 'a', confirm: 'a' })).toBe(true)
+    expect(rule.validate('a', { password: 'a', confirm: 'b' })).toBe(false)
+  })
+
+  it('JsonRule validates JSON strings', () => {
+    const rule = new JsonRule()
+
+    expect(rule.validate('')).toBe(true)
+    expect(rule.validate('{"ok":true}')).toBe(true)
+    expect(rule.validate('{ bad }')).toBe(false)
+    expect(rule.validate(123)).toBe(false)
+  })
+
+  it('ValidationMode has combined flags', () => {
+    expect(ValidationMode.DEFAULT).toBe(ValidationMode.ON_TOUCH | ValidationMode.ON_DIRTY | ValidationMode.ON_SUBMIT)
+    expect(ValidationMode.AGGRESSIVE).toBe(
+      ValidationMode.INSTANTLY | ValidationMode.ON_TOUCH | ValidationMode.ON_DIRTY | ValidationMode.ON_SUBMIT
+    )
+    expect(ValidationMode.PASSIVE).toBe(ValidationMode.ON_SUBMIT)
+  })
+})

package/tests/vue/requests/VueRequestLoaders.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from 'vitest'
+import { VueRequestLoader } from '../../../src/vue/requests/loaders/VueRequestLoader'
+import { VueRequestBatchLoader } from '../../../src/vue/requests/loaders/VueRequestBatchLoader'
+import { VueRequestLoaderFactory } from '../../../src/vue/requests/factories/VueRequestLoaderFactory'
+
+
+describe('Vue request loaders', () => {
+  it('VueRequestLoader tracks loading state', () => {
+    const loader = new VueRequestLoader()
+
+    expect(loader.isLoading().value).toBe(false)
+
+    loader.setLoading(true)
+    expect(loader.isLoading().value).toBe(true)
+
+    loader.setLoading(false)
+    expect(loader.isLoading().value).toBe(false)
+  })
+
+  it('VueRequestBatchLoader tracks batch state', () => {
+    const loader = new VueRequestBatchLoader(2)
+
+    expect(loader.isLoading().value).toBe(true)
+
+    loader.setLoading(true)
+    expect(loader.isLoading().value).toBe(true)
+
+    loader.setLoading(false)
+    expect(loader.isLoading().value).toBe(true)
+
+    loader.setLoading(false)
+    expect(loader.isLoading().value).toBe(false)
+
+    loader.startBatch(1)
+    expect(loader.isLoading().value).toBe(true)
+
+    loader.abortBatch()
+    expect(loader.isLoading().value).toBe(false)
+  })
+
+  it('VueRequestLoaderFactory creates a loader', () => {
+    const factory = new VueRequestLoaderFactory()
+
+    const loader = factory.make()
+
+    expect(loader.isLoading().value).toBe(false)
+  })
+})

package/tests/vue/router/routeResourceBinding/RouteResourceUtils.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it, vi } from 'vitest'
+import { reactive } from 'vue'
+import { defineRoute } from '../../../../src/vue/router/routeResourceBinding/defineRoute'
+import { RouteResourceRequestResolver } from '../../../../src/vue/router/routeResourceBinding/RouteResourceRequestResolver'
+import { useRouteResource } from '../../../../src/vue/router/routeResourceBinding/useRouteResource'
+
+const mockRoute = reactive({
+  meta: {} as Record<string, unknown>,
+})
+
+vi.mock('vue-router', () => ({
+  useRoute: () => mockRoute,
+}))
+
+describe('Route resource helpers', () => {
+  it('RouteResourceRequestResolver resolves data from request', async () => {
+    const request = {
+      send: vi.fn().mockResolvedValue({ getData: () => ({ id: 1 }) }),
+    }
+
+    const resolver = new RouteResourceRequestResolver(request)
+    await expect(resolver.resolve()).resolves.toEqual({ id: 1 })
+  })
+
+  it('useRouteResource exposes loading, error, and refresh', async () => {
+    const refreshMock = vi.fn().mockResolvedValue('ok')
+    mockRoute.meta = {
+      refresh: refreshMock,
+      _injectionState: { product: { loading: true, error: new Error('fail') } },
+    }
+
+    const { isLoading, error, refresh } = useRouteResource('product')
+
+    expect(isLoading.value).toBe(true)
+    expect(error.value).toBeInstanceOf(Error)
+
+    await refresh({ silent: true })
+    expect(refreshMock).toHaveBeenCalledWith('product', { silent: true })
+  })
+
+  it('defineRoute moves meta config and merges injected props', () => {
+    const ErrorComp = { name: 'ErrorComp' }
+    const LoadingComp = { name: 'LoadingComp' }
+
+    const route = defineRoute<{ product: string }>()({
+      path: '/products/:id',
+      component: { name: 'Page' },
+      props: true,
+      errorComponent: ErrorComp,
+      loadingComponent: LoadingComp,
+      lazy: true,
+      meta: {},
+    })
+
+    expect((route.meta as Record<string, unknown>)._errorComponent).toBe(ErrorComp)
+    expect((route.meta as Record<string, unknown>)._loadingComponent).toBe(LoadingComp)
+    expect((route.meta as Record<string, unknown>)._lazy).toBe(true)
+    expect((route as Record<string, unknown>).errorComponent).toBeUndefined()
+    expect((route as Record<string, unknown>).loadingComponent).toBeUndefined()
+    expect((route as Record<string, unknown>).lazy).toBeUndefined()
+
+    const propsFn = route.props as (to: { params: Record<string, unknown>; meta: Record<string, unknown> }) => Record<string, unknown>
+    const props = propsFn({
+      params: { id: 5 },
+      meta: { _injectedProps: { product: 'Widget' } },
+    })
+
+    expect(props).toEqual({ id: 5, product: 'Widget' })
+  })
+})