@fmidev/smartmet-alert-client 4.4.19 → 4.7.0-beta.0

package/tests/unit/composables/useConfig.spec.ts

@@ -0,0 +1,279 @@
+import { describe, it, expect } from 'vitest'
+import { useConfig } from '@/composables/useConfig'
+
+describe('useConfig composable', () => {
+  const config = useConfig()
+
+  describe('Configuration constants', () => {
+    it('should define timezone', () => {
+      expect(config.timeZone).toBe('Europe/Helsinki')
+    })
+
+    it('should define date format locale', () => {
+      expect(config.dateTimeFormatLocale).toBe('fi-FI')
+    })
+
+    it('should define pan limits', () => {
+      expect(config.panLimits).toEqual({ x: 175, y: 275 })
+    })
+
+    it('should define coverage criterion', () => {
+      expect(config.coverageCriterion).toBe(0.2)
+    })
+
+    it('should define max merged weight', () => {
+      expect(config.maxMergedWeight).toBe(7)
+    })
+
+    it('should define max update delays', () => {
+      expect(config.maxUpdateDelay).toHaveProperty('weather_update_time')
+      expect(config.maxUpdateDelay).toHaveProperty('flood_update_time')
+      expect(config.maxUpdateDelay.weather_update_time).toBe(
+        12 * 60 * 60 * 1000
+      )
+    })
+  })
+
+  describe('Warning types map', () => {
+    it('should have warningTypes map', () => {
+      expect(config.warningTypes).toBeInstanceOf(Map)
+    })
+
+    it('should map land warning types', () => {
+      const landTypes = [
+        'thunderStorm',
+        'wind',
+        'rain',
+        'trafficWeather',
+        'pedestrianSafety',
+        'forestFireWeather',
+        'grassFireWeather',
+        'hotWeather',
+        'coldWeather',
+        'uvNote',
+        'floodLevel',
+      ]
+
+      landTypes.forEach((type) => {
+        expect(config.warningTypes.get(type)).toBe('land')
+      })
+    })
+
+    it('should map sea warning types', () => {
+      const seaTypes = [
+        'seaWind',
+        'seaThunderStorm',
+        'seaWaterHeightHighWater',
+        'seaWaterHeightShallowWater',
+        'seaWaveHeight',
+        'seaIcing',
+      ]
+
+      seaTypes.forEach((type) => {
+        expect(config.warningTypes.get(type)).toBe('sea')
+      })
+    })
+  })
+
+  describe('Region IDs', () => {
+    it('should have regionIds array', () => {
+      expect(Array.isArray(config.regionIds)).toBe(true)
+      expect(config.regionIds.length).toBeGreaterThan(0)
+    })
+
+    it('should include county regions', () => {
+      expect(config.regionIds).toContain('county.1')
+      expect(config.regionIds).toContain('county.2')
+    })
+
+    it('should include sea regions', () => {
+      expect(config.regionIds).toContain('sea_region.B1N')
+      expect(config.regionIds).toContain('sea_region.B2')
+    })
+
+    it('should include municipality regions', () => {
+      expect(config.regionIds).toContain('municipality.615')
+    })
+  })
+
+  describe('Geometries', () => {
+    it('should have geometries object', () => {
+      expect(config.geometries).toBeDefined()
+      expect(config.geometries).toHaveProperty('2021')
+    })
+
+    it('should have geometry data for counties', () => {
+      const geometryData = config.geometries[2021]
+      expect(geometryData).toBeDefined()
+
+      const county1 = geometryData?.['county.1']
+      expect(county1).toBeDefined()
+      expect(county1).toHaveProperty('name')
+      expect(county1).toHaveProperty('type')
+      expect(county1).toHaveProperty('weight')
+      expect(county1).toHaveProperty('center')
+      expect(county1).toHaveProperty('pathLarge')
+      expect(county1).toHaveProperty('pathSmall')
+    })
+
+    it('should mark land regions correctly', () => {
+      const geometryData = config.geometries[2021]
+      const county = geometryData?.['county.1'] as
+        | { type: string; name: string }
+        | undefined
+      expect(county?.type).toBe('land')
+    })
+
+    it('should mark sea regions correctly', () => {
+      const geometryData = config.geometries[2021]
+      const seaRegion = geometryData?.['sea_region.B1N'] as
+        | { type: string; name: string }
+        | undefined
+      expect(seaRegion?.type).toBe('sea')
+    })
+
+    it('should have borders data', () => {
+      const geometryData = config.geometries[2021]
+      expect(geometryData).toBeDefined()
+
+      const borders = geometryData?.borders
+      expect(borders).toBeDefined()
+      expect(borders).toHaveProperty('land')
+      expect(borders).toHaveProperty('sea')
+      expect(borders?.land).toHaveProperty('pathLarge')
+      expect(borders?.sea).toHaveProperty('pathLarge')
+    })
+
+    it('should include parent-child relationships', () => {
+      const geometryData = config.geometries[2021]
+      const municipality = geometryData?.['municipality.615'] as
+        | { parent: string; name: string }
+        | undefined
+
+      expect(municipality).toBeDefined()
+      expect(municipality).toHaveProperty('parent')
+      expect(municipality?.parent).toBe('county.17')
+    })
+  })
+
+  describe('Colors configuration', () => {
+    it('should have colors for all themes', () => {
+      expect(config.colors).toHaveProperty('light-theme')
+      expect(config.colors).toHaveProperty('dark-theme')
+      expect(config.colors).toHaveProperty('light-gray-theme')
+      expect(config.colors).toHaveProperty('dark-gray-theme')
+    })
+
+    it('should define severity levels colors', () => {
+      const lightTheme = config.colors['light-theme']
+
+      expect(lightTheme.levels).toHaveLength(5)
+      expect(lightTheme).toHaveProperty('sea')
+      expect(lightTheme).toHaveProperty('missing')
+      expect(lightTheme).toHaveProperty('stroke')
+    })
+
+    it('should have different colors for gray themes', () => {
+      const lightTheme = config.colors['light-theme']
+      const grayTheme = config.colors['light-gray-theme']
+
+      expect(lightTheme.levels).not.toEqual(grayTheme.levels)
+    })
+  })
+
+  describe('Warning icon method', () => {
+    it('should generate wind icon with direction', () => {
+      const warning = {
+        type: 'wind',
+        direction: 90,
+        severity: 3 as const,
+      }
+
+      const icon = config.warningIcon(warning)
+
+      expect(icon).toHaveProperty('aspectRatio')
+      expect(icon).toHaveProperty('geom')
+      expect(icon.geom).toContain('wind-symbol')
+    })
+
+    it('should generate thunder storm icon', () => {
+      const warning = {
+        type: 'thunderStorm',
+        severity: 3 as const,
+      }
+
+      const icon = config.warningIcon(warning)
+
+      expect(icon.geom).toContain('thunder-symbol')
+    })
+
+    it('should generate rain icon', () => {
+      const warning = {
+        type: 'rain',
+        severity: 3 as const,
+      }
+
+      const icon = config.warningIcon(warning)
+
+      expect(icon.geom).toContain('rain-symbol')
+    })
+
+    it('should generate traffic weather icon', () => {
+      const warning = {
+        type: 'trafficWeather',
+        severity: 3 as const,
+      }
+
+      const icon = config.warningIcon(warning)
+
+      expect(icon.geom).toContain('traffic-symbol')
+    })
+
+    it('should generate sea wind icon with text', () => {
+      const warning = {
+        type: 'seaWind',
+        direction: 180,
+        text: '15',
+        severity: 3 as const,
+      }
+
+      const icon = config.warningIcon(warning)
+
+      expect(icon.geom).toContain('seawind-symbol')
+      expect(icon.geom).toContain('15')
+    })
+
+    it('should generate flood icon based on severity', () => {
+      const warning = {
+        type: 'floodLevel',
+        severity: 3 as const,
+      }
+
+      const icon = config.warningIcon(warning)
+
+      expect(icon.geom).toContain('flood-level-3')
+    })
+
+    it('should generate multiple warnings icon', () => {
+      const warning = {
+        type: 'multiple',
+        severity: 3 as const,
+      }
+
+      const icon = config.warningIcon(warning)
+
+      expect(icon.geom).toContain('multiple-symbol')
+    })
+
+    it('should set scale for specific warning types', () => {
+      const warning = {
+        type: 'hotWeather',
+        severity: 3 as const,
+      }
+
+      const icon = config.warningIcon(warning)
+
+      expect(icon.scale).toBe(1.2)
+    })
+  })
+})

package/tests/unit/composables/useI18n.spec.ts

@@ -0,0 +1,116 @@
+import { describe, it, expect } from 'vitest'
+import { ref } from 'vue'
+import { useI18n } from '@/composables/useI18n'
+
+describe('useI18n composable', () => {
+  describe('t() function with plain language string', () => {
+    it('should return Finnish translation', () => {
+      const { t } = useI18n('fi')
+
+      const result = t('noWarnings')
+      expect(result).toBeTruthy()
+      expect(typeof result).toBe('string')
+    })
+
+    it('should return English translation', () => {
+      const { t } = useI18n('en')
+
+      const result = t('noWarnings')
+      expect(result).toBeTruthy()
+      expect(typeof result).toBe('string')
+    })
+
+    it('should return Swedish translation', () => {
+      const { t } = useI18n('sv')
+
+      const result = t('noWarnings')
+      expect(result).toBeTruthy()
+      expect(typeof result).toBe('string')
+    })
+
+    it('should return empty string for unknown language', () => {
+      const { t } = useI18n('de')
+
+      const result = t('noWarnings')
+      expect(result).toBe('')
+    })
+
+    it('should return empty string for null key', () => {
+      const { t } = useI18n('fi')
+
+      const result = t(null)
+      expect(result).toBe('')
+    })
+
+    it('should return empty string for undefined key', () => {
+      const { t } = useI18n('fi')
+
+      const result = t(undefined)
+      expect(result).toBe('')
+    })
+
+    it('should return empty string for non-existent key', () => {
+      const { t } = useI18n('fi')
+
+      const result = t('nonExistentKey12345')
+      expect(result).toBe('')
+    })
+
+    it('should sanitize HTML in translations', () => {
+      const { t } = useI18n('fi')
+
+      // Assuming translations don't contain scripts
+      const result = t('noWarnings')
+      expect(result).not.toContain('<script>')
+      expect(result).not.toContain('javascript:')
+    })
+
+    it('should handle all common translation keys', () => {
+      const { t } = useI18n('fi')
+
+      const commonKeys = [
+        'noWarnings',
+        'validWarnings',
+        'toContent',
+        'supportedBrowsers',
+        'floodLink',
+        'floodLinkText',
+      ]
+
+      commonKeys.forEach((key) => {
+        const result = t(key)
+        expect(typeof result).toBe('string')
+      })
+    })
+  })
+
+  describe('t() function with reactive language ref', () => {
+    it('should return translation based on current ref value', () => {
+      const language = ref('fi')
+      const { t } = useI18n(language)
+
+      const result = t('noWarnings')
+      expect(result).toBeTruthy()
+      expect(typeof result).toBe('string')
+    })
+
+    it('should return empty string when ref value is null', () => {
+      const language = ref<string | null>(null)
+      const { t } = useI18n(language)
+
+      const result = t('noWarnings')
+      expect(result).toBe('')
+    })
+
+    it('should return translation for different languages', () => {
+      const language = ref('en')
+      const { t } = useI18n(language)
+
+      const resultEn = t('noWarnings')
+      expect(resultEn).toBeTruthy()
+
+      // Note: In a real scenario, changing the ref would require re-calling t()
+      // The composable evaluates the language at call time
+    })
+  })
+})

package/tests/unit/composables/useKeyCodes.spec.ts

@@ -0,0 +1,27 @@
+import { describe, it, expect } from 'vitest'
+import { useKeyCodes } from '@/composables/useKeyCodes'
+
+describe('useKeyCodes composable', () => {
+  const keyCodes = useKeyCodes()
+
+  it('should define KEY_CODE_END', () => {
+    expect(keyCodes.KEY_CODE_END).toBe(35)
+  })
+
+  it('should define KEY_CODE_HOME', () => {
+    expect(keyCodes.KEY_CODE_HOME).toBe(36)
+  })
+
+  it('should define KEY_CODE_LEFT', () => {
+    expect(keyCodes.KEY_CODE_LEFT).toBe(37)
+  })
+
+  it('should define KEY_CODE_RIGHT', () => {
+    expect(keyCodes.KEY_CODE_RIGHT).toBe(39)
+  })
+
+  it('should have all arrow key codes', () => {
+    expect(keyCodes.KEY_CODE_LEFT).toBeLessThan(keyCodes.KEY_CODE_RIGHT)
+    expect(keyCodes.KEY_CODE_HOME).toBeLessThan(keyCodes.KEY_CODE_RIGHT)
+  })
+})

package/tests/unit/composables/useUtils.spec.ts

@@ -0,0 +1,213 @@
+import { describe, it, expect } from 'vitest'
+import {
+  uncapitalize,
+  twoDigits,
+  warningType,
+  regionFromReference,
+  relativeCoverageFromReference,
+  toTimeZone,
+  msSinceStartOfDay,
+  validInterval,
+} from '@/composables/useUtils'
+
+describe('useUtils composable - pure functions', () => {
+  describe('uncapitalize', () => {
+    it('should uncapitalize first letter', () => {
+      expect(uncapitalize('HelloWorld')).toBe('helloWorld')
+    })
+
+    it('should handle empty string', () => {
+      expect(uncapitalize('')).toBe('')
+    })
+
+    it('should handle null', () => {
+      expect(uncapitalize(null)).toBe('')
+    })
+
+    it('should handle single character', () => {
+      expect(uncapitalize('A')).toBe('a')
+    })
+  })
+
+  describe('warningType', () => {
+    it('should parse thunderStorm type correctly', () => {
+      const result = warningType({
+        warning_context: 'thunder-storm',
+      })
+      expect(result).toBe('thunderStorm')
+    })
+
+    it('should parse wind type correctly', () => {
+      const result = warningType({
+        warning_context: 'wind',
+      })
+      expect(result).toBe('wind')
+    })
+
+    it('should handle sea-wind with extension', () => {
+      const result = warningType({
+        warning_context: 'sea-wind',
+      })
+      expect(result).toBe('seaWind')
+    })
+
+    it('should handle context with extension', () => {
+      const result = warningType({
+        warning_context: 'sea-water-height',
+        context_extension: 'high-water',
+      })
+      expect(result).toBe('seaWaterHeightHighWater')
+    })
+
+    it('should handle multi-word contexts', () => {
+      const result = warningType({
+        warning_context: 'forest-fire-weather',
+      })
+      expect(result).toBe('forestFireWeather')
+    })
+  })
+
+  describe('regionFromReference', () => {
+    it('should parse single region reference', () => {
+      const result = regionFromReference('fi-warning#county.1')
+      expect(result).toBe('county.1')
+    })
+
+    it('should parse merged region reference', () => {
+      const result = regionFromReference(
+        'fi-warning#county.1,fi-warning#county.2'
+      )
+      expect(result).toBe('county_1.2')
+    })
+
+    it('should parse multiple merged regions', () => {
+      const result = regionFromReference(
+        'fi-warning#county.1,fi-warning#county.2,fi-warning#county.3'
+      )
+      expect(result).toBe('county_1_2.3')
+    })
+
+    it('should handle Saimaa special case (lake region)', () => {
+      const result = regionFromReference(
+        'fi-warning#sea_region_south.FI-115978'
+      )
+      expect(result).toBe('sea_region_south.FI-115978')
+    })
+  })
+
+  describe('relativeCoverageFromReference', () => {
+    it('should extract coverage from reference URL', () => {
+      const result = relativeCoverageFromReference('fi-warning#county.1?c=75')
+      expect(result).toBe(75)
+    })
+
+    it('should return 0 when no coverage parameter', () => {
+      const result = relativeCoverageFromReference('fi-warning#county.1')
+      expect(result).toBe(0)
+    })
+
+    it('should return 0 when no query string', () => {
+      const result = relativeCoverageFromReference('county.1')
+      expect(result).toBe(0)
+    })
+
+    it('should return 0 for null reference', () => {
+      const result = relativeCoverageFromReference(null)
+      expect(result).toBe(0)
+    })
+
+    it('should handle URL with hash fragment', () => {
+      const result = relativeCoverageFromReference(
+        'fi-warning#county.1?c=50#fragment'
+      )
+      expect(result).toBe(50)
+    })
+  })
+
+  describe('twoDigits', () => {
+    it('should pad single digit with zero', () => {
+      expect(twoDigits(5)).toBe('05')
+    })
+
+    it('should not pad double digit', () => {
+      expect(twoDigits(15)).toBe('15')
+    })
+
+    it('should handle zero', () => {
+      expect(twoDigits(0)).toBe('00')
+    })
+  })
+
+  describe('toTimeZone', () => {
+    const timeZone = 'Europe/Helsinki'
+    const locale = 'fi-FI'
+
+    it('should convert UTC to Helsinki timezone', () => {
+      const date = new Date('2025-10-31T12:00:00Z')
+      const result = toTimeZone(date, timeZone, locale)
+
+      expect(result.timeZone).toBe('Europe/Helsinki')
+      expect(result.year).toBe(2025)
+      expect(result.month).toBe(10)
+      expect(result.day).toBe(31)
+      // Helsinki is UTC+2 during DST (summer) or UTC+2 after DST ends
+      expect(result.hour).toBe(14)
+    })
+
+    it('should handle different date formats', () => {
+      const date = '2025-10-31T12:00:00Z'
+      const result = toTimeZone(date, timeZone, locale)
+
+      expect(result.year).toBe(2025)
+      expect(result.month).toBe(10)
+      expect(result.day).toBe(31)
+    })
+  })
+
+  describe('msSinceStartOfDay', () => {
+    const timeZone = 'Europe/Helsinki'
+    const locale = 'fi-FI'
+
+    it('should calculate milliseconds since start of day', () => {
+      // 12:00:00 UTC = 14:00 in Helsinki (UTC+2)
+      const timestamp = new Date('2025-10-31T12:00:00Z').getTime()
+      const result = msSinceStartOfDay(timestamp, timeZone, locale)
+
+      // 14 * 60 * 60 * 1000 = 50400000 ms
+      expect(result).toBeGreaterThan(40000000) // At least 11+ hours
+      expect(result).toBeLessThan(60000000) // Less than 17 hours
+    })
+
+    it('should handle midnight', () => {
+      const timestamp = new Date('2025-10-31T00:00:00Z').getTime()
+      const result = msSinceStartOfDay(timestamp, timeZone, locale)
+
+      expect(result).toBeGreaterThanOrEqual(0)
+      expect(result).toBeLessThan(24 * 60 * 60 * 1000)
+    })
+  })
+
+  describe('validInterval', () => {
+    const timeZone = 'Europe/Helsinki'
+    const locale = 'fi-FI'
+
+    it('should format time interval correctly', () => {
+      const start = '2025-10-31T12:00:00Z'
+      const end = '2025-11-01T18:00:00Z'
+      const result = validInterval(start, end, timeZone, locale)
+
+      // Should contain both dates and times
+      expect(result).toContain('31.10.')
+      expect(result).toContain('1.11.')
+      expect(result).toContain('–') // en-dash separator
+    })
+
+    it('should include time in HH:MM format', () => {
+      const start = '2025-10-31T12:00:00Z'
+      const end = '2025-10-31T18:00:00Z'
+      const result = validInterval(start, end, timeZone, locale)
+
+      expect(result).toMatch(/\d{2}:\d{2}/)
+    })
+  })
+})

package/tsconfig.json

@@ -0,0 +1,43 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "preserve",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+
+    /* Path aliases */
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    },
+
+    /* Types */
+    "types": ["vitest/globals", "node"]
+  },
+  "include": [
+    "src/**/*.ts",
+    "src/**/*.tsx",
+    "src/**/*.vue",
+    "src/**/*.d.ts",
+    "tests/**/*.ts",
+    "vite.config.ts"
+  ],
+  "exclude": ["node_modules", "dist"],
+  "references": [{ "path": "./tsconfig.node.json" }]
+}

package/tsconfig.node.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true,
+    "strict": true
+  },
+  "include": ["vite.config.ts", "vitest.config.ts"]
+}