@lukso/core 0.1.0-dev.0f1bea5

package/src/services/__tests__/intl.spec.ts

@@ -0,0 +1,536 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  clearIntlService,
+  createIntlService,
+  defaultConfig,
+  getIntlService,
+  setIntlService,
+} from '../intl'
+
+describe('Intl service', () => {
+  beforeEach(() => {
+    // Mock the date to 2024-12-01 12:00 UTC for consistent testing
+    // TZ env var is set to UTC in vitest config
+    vi.useFakeTimers()
+    vi.setSystemTime(new Date('2024-12-01T12:00:00Z'))
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+    clearIntlService()
+  })
+
+  describe('createIntlService', () => {
+    it('should create an intl service instance with default config', () => {
+      const intl = createIntlService()
+      expect(intl).toBeDefined()
+      expect(intl.getLocale()).toBe('en-US')
+    })
+
+    it('should create an intl service instance with custom config', () => {
+      const customMessages = { greeting: 'Hello, {name}!' }
+      const intl = createIntlService({
+        locale: 'de-DE',
+        messages: customMessages,
+      })
+      expect(intl.getLocale()).toBe('de-DE')
+    })
+
+    it('should have all required methods', () => {
+      const intl = createIntlService()
+      expect(intl.formatMessage).toBeDefined()
+      expect(intl.formatNumber).toBeDefined()
+      expect(intl.formatDate).toBeDefined()
+      expect(intl.formatTime).toBeDefined()
+      expect(intl.formatTimestamp).toBeDefined()
+      expect(intl.setLocale).toBeDefined()
+      expect(intl.getLocale).toBeDefined()
+      expect(intl.localeChanged).toBeDefined()
+    })
+  })
+
+  describe('formatMessage', () => {
+    it('should return the key if message is not found', () => {
+      const intl = createIntlService()
+      expect(intl.formatMessage('non_existent_key')).toBe('non_existent_key')
+    })
+
+    it('should return translated message when found', () => {
+      const messages = { greeting: 'Hello' }
+      const intl = createIntlService({
+        locale: 'en-US',
+        messages,
+      })
+      expect(intl.formatMessage('greeting')).toBe('Hello')
+    })
+
+    it('should interpolate variables in messages', () => {
+      const messages = { greeting: 'Hello, {name}!' }
+      const intl = createIntlService({
+        locale: 'en-US',
+        messages,
+      })
+      const result = intl.formatMessage('greeting', { name: 'John' })
+      expect(result).toBe('Hello, John!')
+    })
+
+    it('should not interpolate variables in HTML messages', () => {
+      const messages = { greeting: 'Hello, <b>{name}!</b>' }
+      const intl = createIntlService({
+        locale: 'en-US',
+        messages,
+      })
+      const result = intl.formatMessage('greeting', { name: 'John' })
+      expect(result).toBe('Hello, <b>{name}!</b>')
+    })
+
+    it('should interpolate variables in injected HTML messages', () => {
+      const messages = { greeting: 'Hello, {name}!' }
+      const intl = createIntlService({
+        locale: 'en-US',
+        messages,
+      })
+      const result = intl.formatMessage('greeting', { name: '<b>John</b>' })
+      expect(result).toBe('Hello, <b>John</b>!')
+    })
+
+    it('should handle missing translation gracefully', () => {
+      const intl = createIntlService()
+      expect(() => intl.formatMessage('missing_key')).not.toThrow()
+    })
+
+    it('should handle dot notation keys', () => {
+      const messages = {
+        'app.title': 'My Application',
+      }
+      const intl = createIntlService({
+        locale: 'en-US',
+        messages,
+      })
+      expect(intl.formatMessage('app.title')).toBe('My Application')
+    })
+  })
+
+  describe('formatNumber', () => {
+    it('should format a number with default options', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      const result = intl.formatNumber(1234.5)
+      expect(result).toBe('1,234.5')
+    })
+
+    it('should format a string number', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      const result = intl.formatNumber('1234.5')
+      expect(result).toBe('1,234.5')
+    })
+
+    it('should format a bigint', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      const result = intl.formatNumber(BigInt('1234567890'))
+      expect(result).toBe('1,234,567,890')
+    })
+
+    it('should return 0 for null or undefined', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      expect(intl.formatNumber(null as any)).toBe('0')
+      expect(intl.formatNumber(undefined as any)).toBe('0')
+    })
+
+    it('should accept custom format options', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      const result = intl.formatNumber(1234.56789, {
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2,
+      })
+      expect(result).toBe('1,234.57')
+    })
+
+    it('should use default maximum fraction digits of 18', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      // biome-ignore lint/correctness/noPrecisionLoss: because of testing
+      const result = intl.formatNumber(0.123456789012345678123)
+      expect(result).toBe('0.12345678901234568')
+    })
+  })
+
+  describe('formatDate', () => {
+    it('should format a Date object', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      const date = new Date('2024-12-02T12:00:00Z')
+      const result = intl.formatDate(date)
+      expect(result).toBe('12/2/2024')
+    })
+
+    it('should format a timestamp number', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      const timestamp = 1733144400000 // 2024-12-02
+      const result = intl.formatDate(timestamp)
+      expect(result).toBe('12/2/2024')
+    })
+
+    it('should format a date string', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      const result = intl.formatDate('2024-12-02')
+      expect(result).toBe('12/2/2024')
+    })
+
+    it('should format a date when given undefined input', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      const result = intl.formatDate(undefined)
+      // Should format the mocked date (2024-12-02)
+      expect(result).toBe('12/1/2024')
+    })
+  })
+
+  describe('formatTime', () => {
+    it('should format a Date object as time', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      const date = new Date('2024-12-02T14:30:00Z')
+      const result = intl.formatTime(date)
+      expect(result).toBe('2:30 PM')
+    })
+
+    it('should format a timestamp number as time', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      const timestamp = 1733151000000 // 2024-12-02T14:30:00Z
+      const result = intl.formatTime(timestamp)
+      expect(result).toBe('2:50 PM')
+    })
+
+    it('should format current time when given undefined input', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      const result = intl.formatTime(undefined)
+      // Should format the mocked time (2024-12-01T12:00:00Z = 12:00 PM in UTC)
+      expect(result).toBe('12:00 PM')
+    })
+  })
+
+  describe('formatTimestamp', () => {
+    it('should format a UNIX timestamp in seconds', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      const timestamp = 1733144400 // 2024-12-02 in seconds
+      const result = intl.formatTimestamp(timestamp)
+      expect(result).toBe('12/2/2024')
+    })
+
+    it('should format a UNIX timestamp as string', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      const result = intl.formatTimestamp('1733144400')
+      expect(result).toBe('12/2/2024')
+    })
+
+    it('should return empty string for undefined or null', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      expect(intl.formatTimestamp('')).toBe('')
+      expect(intl.formatTimestamp(undefined)).toBe('')
+      expect(intl.formatTimestamp(null as any)).toBe('')
+    })
+
+    it('should accept custom DateTimeFormat options', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      const timestamp = 1733144400
+      const result = intl.formatTimestamp(timestamp, {
+        year: 'numeric',
+        month: 'long',
+        day: 'numeric',
+      })
+      expect(result).toBe('December 2, 2024')
+    })
+
+    it('can use custom format', () => {
+      const intl = createIntlService({
+        locale: 'en-US',
+        messages: {},
+        formats: {
+          date: {
+            shortDateTime: {
+              weekday: 'short', // Wed
+              month: 'short', // Dec
+              day: 'numeric', // 3
+              year: 'numeric', // 2025
+              hour: '2-digit', // 16
+              minute: '2-digit', // 07
+              hour12: false,
+            },
+          },
+        },
+      })
+      const timestamp = 1733144400 // 2024-12-02T14:00:00Z
+      const result = intl.formatTimestamp(timestamp, 'shortDateTime')
+      expect(result).toBe('Mon, Dec 2, 2024, 13:00')
+    })
+  })
+
+  describe('setLocale', () => {
+    it('should change the locale', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      intl.setLocale('de-DE')
+      expect(intl.getLocale()).toBe('de-DE')
+    })
+
+    it('should update messages when provided', () => {
+      const enMessages = { greeting: 'Hello' }
+      const deMessages = { greeting: 'Hallo' }
+      const intl = createIntlService({
+        locale: 'en-US',
+        messages: enMessages,
+      })
+
+      intl.setLocale('de-DE', deMessages)
+      expect(intl.getLocale()).toBe('de-DE')
+      expect(intl.formatMessage('greeting')).toBe('Hallo')
+    })
+
+    it('should keep existing messages if not provided', () => {
+      const messages = { greeting: 'Hello' }
+      const intl = createIntlService({
+        locale: 'en-US',
+        messages,
+      })
+
+      intl.setLocale('de-DE')
+      expect(intl.getLocale()).toBe('de-DE')
+    })
+
+    it('should increment localeChanged signal', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      const initialValue = intl.localeChanged.value
+
+      intl.setLocale('de-DE')
+      expect(intl.localeChanged.value).toBe(initialValue + 1)
+
+      intl.setLocale('fr-FR')
+      expect(intl.localeChanged.value).toBe(initialValue + 2)
+    })
+  })
+
+  describe('getLocale', () => {
+    it('should return the current locale', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      expect(intl.getLocale()).toBe('en-US')
+    })
+
+    it('should return updated locale after setLocale', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      intl.setLocale('de-DE')
+      expect(intl.getLocale()).toBe('de-DE')
+    })
+  })
+
+  describe('localeChanged signal', () => {
+    it('should have an initial value of 0', () => {
+      const intl = createIntlService()
+      expect(intl.localeChanged.value).toBe(0)
+    })
+
+    it('should increment when locale changes', () => {
+      const intl = createIntlService()
+      expect(intl.localeChanged.value).toBe(0)
+
+      intl.setLocale('de-DE')
+      expect(intl.localeChanged.value).toBe(1)
+
+      intl.setLocale('fr-FR')
+      expect(intl.localeChanged.value).toBe(2)
+    })
+
+    it('should be observable', () => {
+      const intl = createIntlService()
+      let callCount = 0
+      const signal = intl.localeChanged
+
+      // Create a simple effect to track changes
+      const initialValue = signal.value
+      intl.setLocale('de-DE')
+      expect(signal.value).toBeGreaterThan(initialValue)
+      callCount++
+
+      expect(callCount).toBe(1)
+    })
+  })
+
+  describe('global service management', () => {
+    it('should set and get global intl service', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      setIntlService(intl)
+
+      const retrieved = getIntlService()
+      expect(retrieved).toBe(intl)
+    })
+
+    it('should return null if no service is set', () => {
+      clearIntlService()
+      expect(getIntlService()).toBeNull()
+    })
+
+    it('should clear the global service', () => {
+      const intl = createIntlService()
+      setIntlService(intl)
+      expect(getIntlService()).toBe(intl)
+
+      clearIntlService()
+      expect(getIntlService()).toBeNull()
+    })
+
+    it('should support multiple service instances', () => {
+      const intl1 = createIntlService({ locale: 'en-US', messages: {} })
+      const intl2 = createIntlService({ locale: 'de-DE', messages: {} })
+
+      expect(intl1.getLocale()).toBe('en-US')
+      expect(intl2.getLocale()).toBe('de-DE')
+
+      setIntlService(intl1)
+      expect(getIntlService()).toBe(intl1)
+
+      setIntlService(intl2)
+      expect(getIntlService()).toBe(intl2)
+    })
+  })
+
+  describe('default config', () => {
+    it('should have correct default config', () => {
+      expect(defaultConfig.locale).toBe('en-US')
+      expect(defaultConfig.messages).toEqual({})
+    })
+
+    it('should use default config when none provided', () => {
+      const intl = createIntlService()
+      expect(intl.getLocale()).toBe(defaultConfig.locale)
+    })
+  })
+
+  describe('locale-specific formatting', () => {
+    it('should format numbers differently for different locales', () => {
+      const enIntl = createIntlService({ locale: 'en-US', messages: {} })
+      const deIntl = createIntlService({ locale: 'de-DE', messages: {} })
+
+      const enResult = enIntl.formatNumber(1234.56)
+      const deResult = deIntl.formatNumber(1234.56)
+
+      // Numbers may format differently based on locale
+      expect(enResult).toBe('1,234.56')
+      expect(deResult).toBe('1.234,56')
+    })
+
+    it('should format dates differently for different locales', () => {
+      const enIntl = createIntlService({ locale: 'en-US', messages: {} })
+      const deIntl = createIntlService({ locale: 'de-DE', messages: {} })
+
+      const date = new Date('2024-12-02T12:00:00Z')
+      const enResult = enIntl.formatDate(date)
+      const deResult = deIntl.formatDate(date)
+
+      // Dates should format differently based on locale
+      expect(enResult).toBe('12/2/2024')
+      expect(deResult).toBe('2.12.2024')
+    })
+  })
+
+  describe('setFallbackTranslations', () => {
+    it('should return fallback translation for missing keys', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      const fallback = { missing_key: 'Fallback value' }
+      intl.setFallbackTranslations(fallback)
+      expect(intl.formatMessage('missing_key')).toBe('Fallback value')
+    })
+
+    it('should use primary messages before fallback', () => {
+      const messages = { greeting: 'Hello' }
+      const fallback = { greeting: 'Hi' }
+      const intl = createIntlService({
+        locale: 'en-US',
+        messages,
+      })
+      intl.setFallbackTranslations(fallback)
+      expect(intl.formatMessage('greeting')).toBe('Hello')
+    })
+
+    it('should use fallback only for missing translations', () => {
+      const messages = { primary: 'Primary translation' }
+      const fallback = { primary: 'Fallback', fallback: 'Fallback only' }
+      const intl = createIntlService({
+        locale: 'en-US',
+        messages,
+      })
+      intl.setFallbackTranslations(fallback)
+      expect(intl.formatMessage('primary')).toBe('Primary translation')
+      expect(intl.formatMessage('fallback')).toBe('Fallback only')
+    })
+
+    it('should support updating fallback translations', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      const fallback1 = { key: 'First fallback' }
+      const fallback2 = { key: 'Second fallback' }
+
+      intl.setFallbackTranslations(fallback1)
+      expect(intl.formatMessage('key')).toBe('First fallback')
+
+      intl.setFallbackTranslations(fallback2)
+      expect(intl.formatMessage('key')).toBe('Second fallback')
+    })
+
+    it('should return key if neither primary nor fallback translation exists', () => {
+      const fallback = { some_key: 'Fallback text' }
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      intl.setFallbackTranslations(fallback)
+      expect(intl.formatMessage('non_existent_key')).toBe('non_existent_key')
+    })
+
+    it('should accept empty fallback translations', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      intl.setFallbackTranslations({})
+      expect(intl.formatMessage('any_key')).toBe('any_key')
+    })
+
+    it('should work with multiple locale changes and fallback translations', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      const fallback = { greeting: 'Default greeting' }
+      intl.setFallbackTranslations(fallback)
+
+      expect(intl.formatMessage('greeting')).toBe('Default greeting')
+
+      intl.setLocale('de-DE', { greeting: 'Hallo' })
+      expect(intl.formatMessage('greeting')).toBe('Hallo')
+
+      // When switching locale without new messages, intl keeps the existing messages
+      // so the greeting from de-DE remains available
+      intl.setLocale('fr-FR')
+      expect(intl.formatMessage('greeting')).toBe('Hallo')
+    })
+  })
+
+  describe('error handling', () => {
+    it('should not throw when formatting missing messages', () => {
+      const intl = createIntlService()
+      expect(() => {
+        intl.formatMessage('missing.key')
+      }).not.toThrow()
+    })
+
+    it('should return fallback values on errors', () => {
+      const intl = createIntlService()
+      const result = intl.formatMessage('missing.key')
+      expect(result).toBe('missing.key')
+    })
+
+    it('should handle invalid numbers gracefully', () => {
+      const intl = createIntlService()
+      expect(() => {
+        intl.formatNumber(NaN)
+      }).not.toThrow()
+    })
+
+    it('should handle very large numbers', () => {
+      const intl = createIntlService()
+      const result = intl.formatNumber(999999999999999999n)
+      expect(result).toBe('999,999,999,999,999,999')
+    })
+
+    it('should fallback to fallback translations on formatMessage error', () => {
+      const intl = createIntlService({ locale: 'en-US', messages: {} })
+      const fallback = { error_key: 'Error fallback text' }
+      intl.setFallbackTranslations(fallback)
+      expect(intl.formatMessage('error_key')).toBe('Error fallback text')
+    })
+  })
+})

package/src/services/device.ts

@@ -0,0 +1,121 @@
+/**
+ * Device Detection Service
+ *
+ * Provides device type, OS, and browser detection using ua-parser-js
+ */
+
+import { signal } from '@preact/signals-core'
+import { UAParser } from 'ua-parser-js'
+
+/**
+ * Device detection flags and utilities
+ */
+export interface DeviceService {
+  /**
+   * Device type detection flags
+   */
+  isMobile: boolean
+  isTablet: boolean
+  isDesktop: boolean
+
+  /**
+   * Operating system detection flags
+   */
+  isIOS: boolean
+  isAndroid: boolean
+  isWindows: boolean
+  isMacOS: boolean
+  isLinux: boolean
+
+  /**
+   * Browser detection flags
+   */
+  isChrome: boolean
+  isSafari: boolean
+  isFirefox: boolean
+  isEdge: boolean
+  isOpera: boolean
+  isBrave: boolean
+
+  /**
+   * Get raw parser result for additional details
+   * @returns Full UAParser result object
+   */
+  getRaw: () => ReturnType<UAParser['getResult']>
+
+  /**
+   * Signal that tracks device detector initialization
+   * Useful for reactivity in web components
+   */
+  initialized: { value: number }
+}
+
+export interface NavigatorExtended extends Navigator {
+  brave?: unknown
+}
+
+/**
+ * Create a new device detector instance
+ *
+ * @param navigator - Optional custom navigator object (uses global navigator by default)
+ * @returns DeviceService instance with device/OS/browser detection
+ *
+ * @example
+ * ```typescript
+ * import { deviceService } from '@lukso/core/services/device';
+ *
+ * const device = deviceService();
+ *
+ * if (device.isMobile) {
+ *   console.log('User is on mobile');
+ * }
+ * ```
+ */
+export function deviceService(navigator?: NavigatorExtended): DeviceService {
+  const userAgent = navigator?.userAgent ?? ''
+  const parser = new UAParser(userAgent)
+  const result = parser.getResult()
+  const initialized = signal(1)
+
+  // Determine device type
+  const deviceType = result.device.type as 'mobile' | 'tablet' | undefined
+  const isMobile = deviceType === 'mobile'
+  const isTablet = deviceType === 'tablet'
+  const isDesktop = !deviceType
+
+  // Operating system detection
+  const osName = result.os.name || ''
+  const isIOS = osName.includes('iOS') || osName.includes('Mac OS')
+  const isAndroid = osName === 'Android'
+  const isWindows = osName === 'Windows'
+  const isMacOS = osName === 'Mac OS'
+  const isLinux = osName === 'Linux'
+
+  // Browser detection
+  const browserName = result.browser.name || ''
+  const isChrome = browserName === 'Chrome'
+  const isSafari = browserName === 'Safari'
+  const isFirefox = browserName === 'Firefox'
+  const isEdge = browserName === 'Edge'
+  const isOpera = browserName === 'Opera'
+  const isBrave = navigator?.brave !== undefined
+
+  return {
+    isMobile,
+    isTablet,
+    isDesktop,
+    isIOS,
+    isAndroid,
+    isWindows,
+    isMacOS,
+    isLinux,
+    isChrome,
+    isSafari,
+    isFirefox,
+    isEdge,
+    isOpera,
+    isBrave,
+    getRaw: () => result,
+    initialized,
+  }
+}

package/src/services/index.ts

@@ -0,0 +1,17 @@
+/**
+ * @lukso/core - Services
+ *
+ * Core services for device detection, internationalization, and more
+ */
+
+export type { DeviceService, NavigatorExtended } from './device.js'
+export { deviceService } from './device.js'
+
+export type { IntlMessages, IntlService } from './intl.js'
+export {
+  clearIntlService,
+  createIntlService,
+  defaultConfig,
+  getIntlService,
+  setIntlService,
+} from './intl.js'