test(useDate): add coverage for inspection findings

- Add custom adapter type inference test
- Add SSR tests for useDate/createDateFallback outside component
- Add dynamic locale sync test with useLocale integration
- Add leap year and invalid locale edge case tests
- Add locale switching benchmarks (cache eviction, toggle)

Author: johnleider

packages/0/src/composables/useDate/index.bench.ts

@@ -114,5 +114,30 @@ describe('useDate benchmarks', () => {
         _date = adapter.setDate(_date, 1)
       })
     })
+
+    describe('locale switching', () => {
+      bench('locale change + reformat', () => {
+        const localAdapter = new Vuetify0DateAdapter('en-US')
+        localAdapter.locale = 'de-DE'
+        localAdapter.format(testDate, 'fullDate')
+      })
+
+      bench('toggle locale 10 times', () => {
+        const localAdapter = new Vuetify0DateAdapter('en-US')
+
+        for (let i = 0; i < 10; i++) {
+          localAdapter.locale = i % 2 === 0 ? 'de-DE' : 'en-US'
+          localAdapter.format(testDate, 'fullDate')
+        }
+      })
+
+      bench('cache eviction (60 unique formats)', () => {
+        const localAdapter = new Vuetify0DateAdapter('en-US')
+
+        for (let i = 0; i < 60; i++) {
+          localAdapter.formatByString(testDate, `YYYY-MM-DD-${i}`)
+        }
+      })
+    })
   })
 })

packages/0/src/composables/useDate/index.ssr.test.ts

@@ -13,8 +13,49 @@ vi.mock('#v0/constants/globals', () => ({
 
 // Import after mock is set up
 import { Vuetify0DateAdapter } from './adapters/v0'
+import { useDate, createDateFallback } from './index'
 
 describe('useDate SSR', () => {
+  describe('useDate outside component in SSR', () => {
+    it('should return fallback context when called outside component', () => {
+      // In SSR without getCurrentInstance(), useDate should return fallback
+      const ctx = useDate()
+
+      expect(ctx).toBeDefined()
+      expect(ctx.adapter).toBeInstanceOf(Vuetify0DateAdapter)
+      expect(ctx.locale.value).toBe('en-US')
+    })
+
+    it('should return fallback with custom namespace outside component', () => {
+      const ctx = useDate('custom:namespace')
+
+      expect(ctx).toBeDefined()
+      expect(ctx.adapter).toBeInstanceOf(Vuetify0DateAdapter)
+    })
+
+    it('should return epoch from fallback adapter in SSR', () => {
+      const ctx = useDate()
+      const date = ctx.adapter.date()
+
+      // In SSR, date() without args returns epoch
+      expect(date).not.toBeNull()
+      expect(date!.year).toBe(1970)
+      expect(date!.month).toBe(1)
+      expect(date!.day).toBe(1)
+    })
+
+    it('createDateFallback should work in SSR', () => {
+      const fallback = createDateFallback()
+
+      expect(fallback.adapter).toBeInstanceOf(Vuetify0DateAdapter)
+      expect(fallback.locale.value).toBe('en-US')
+
+      // Should use epoch for current date in SSR
+      const date = fallback.adapter.date()
+      expect(date!.year).toBe(1970)
+    })
+  })
+
   describe('Vuetify0DateAdapter in SSR mode', () => {
     it('should return epoch when date() called without arguments', () => {
       const adapter = new Vuetify0DateAdapter('en-US')

packages/0/src/composables/useDate/index.test.ts

@@ -2,6 +2,7 @@ import { describe, it, expect, beforeEach, expectTypeOf } from 'vitest'
 import { Temporal } from '@js-temporal/polyfill'
 import { createDate, createDateContext, createDateFallback, createDatePlugin, useDate } from './index'
 import { Vuetify0DateAdapter } from './adapters/v0'
+import type { DateAdapter, DateContext } from './index'
 
 describe('useDate', () => {
   describe('Vuetify0DateAdapter', () => {
@@ -91,6 +92,21 @@ describe('useDate', () => {
         expect(date).toBeNull()
       })
 
+      it('should create Feb 29 in leap year', () => {
+        const date = adapter.date('2024-02-29T10:30:00')
+
+        expect(date).not.toBeNull()
+        expect(date!.year).toBe(2024)
+        expect(date!.month).toBe(2)
+        expect(date!.day).toBe(29)
+      })
+
+      it('should return null for Feb 29 in non-leap year', () => {
+        const date = adapter.date('2023-02-29T10:30:00')
+
+        expect(date).toBeNull()
+      })
+
       it('should convert to JavaScript Date', () => {
         const temporal = Temporal.PlainDateTime.from('2024-06-15T10:30:00')
         const jsDate = adapter.toJsDate(temporal)
@@ -156,6 +172,16 @@ describe('useDate', () => {
 
         expect(month.toLowerCase()).toContain('juin')
       })
+
+      it('should handle invalid locale gracefully', () => {
+        // Intl.DateTimeFormat falls back to default locale for invalid codes
+        const invalidAdapter = new Vuetify0DateAdapter('invalid-XX')
+        const date = invalidAdapter.date('2024-06-15T10:30:00')!
+
+        // Should not throw, Intl falls back gracefully
+        expect(() => invalidAdapter.format(date, 'fullDate')).not.toThrow()
+        expect(invalidAdapter.format(date, 'year')).toBe('2024')
+      })
     })
 
     describe('navigation - start/end boundaries', () => {
@@ -1373,6 +1399,59 @@ describe('useDate', () => {
 
       wrapper.unmount()
     })
+
+    it('should sync adapter locale dynamically when context created in component', async () => {
+      const { mount } = await import('@vue/test-utils')
+      const { defineComponent, nextTick } = await import('vue')
+      const { createLocalePlugin, useLocale } = await import('#v0/composables/useLocale')
+
+      // Locale plugin provides context at app level
+      const localePlugin = createLocalePlugin({
+        default: 'en',
+        messages: {
+          en: { hello: 'Hello' },
+          de: { hello: 'Hallo' },
+        },
+      })
+
+      let selectLocaleFn: ((id: string) => void) | null = null
+
+      const TestComponent = defineComponent({
+        setup () {
+          const localeContext = useLocale()
+          // Create date context INSIDE component for dynamic sync
+          const dateContext = createDate({
+            localeMap: { en: 'en-US', de: 'de-DE' },
+          })
+
+          selectLocaleFn = localeContext.select
+
+          return {
+            dateLocale: dateContext.locale,
+            adapterLocale: () => dateContext.adapter.locale,
+          }
+        },
+        template: '<div>{{ dateLocale }} - {{ adapterLocale() }}</div>',
+      })
+
+      const wrapper = mount(TestComponent, {
+        global: {
+          plugins: [localePlugin],
+        },
+      })
+
+      // Initial locale should be mapped from useLocale's selection
+      expect(wrapper.text()).toContain('en-US')
+
+      // Change locale dynamically
+      selectLocaleFn!('de')
+      await nextTick()
+
+      // Adapter locale should sync via watchEffect (context created in component)
+      expect(wrapper.text()).toContain('de-DE')
+
+      wrapper.unmount()
+    })
   })
 
   describe('type safety (compile-time)', () => {
@@ -1386,6 +1465,13 @@ describe('useDate', () => {
       const customCtx = createDate({ adapter: customAdapter })
       expectTypeOf(customCtx.adapter.date()).toEqualTypeOf<Temporal.PlainDateTime | null>()
 
+      // Mock adapter with different type: verifies generic inference (type-only)
+      const mockDateAdapter = {} as DateAdapter<Date>
+      const mockCtx = createDate({ adapter: mockDateAdapter })
+      // Type assertions only - mock adapter has no runtime implementation
+      expectTypeOf(mockCtx.adapter).toEqualTypeOf<DateAdapter<Date>>()
+      expectTypeOf(mockCtx).toEqualTypeOf<DateContext<Date>>()
+
       // Context trinity returns correct type
       const [, , ctx] = createDateContext()
       expectTypeOf(ctx.adapter.date()).toEqualTypeOf<Temporal.PlainDateTime | null>()