@i18n-micro/core 1.0.27

package/tests/route-service.test.ts

@@ -0,0 +1,377 @@
+import type {
+  RouteLocationAsPathGeneric,
+  RouteLocationNamedRaw,
+  RouteLocationNormalizedLoaded,
+  RouteLocationRaw,
+  RouteLocationResolvedGeneric,
+  Router,
+} from 'vue-router'
+import type { ModuleOptionsExtend } from '@i18n-micro/types'
+import { RouteService } from '../src'
+
+describe('RouteService', () => {
+  let routeService: RouteService
+  let mockRouter: jest.Mocked<Router>
+  let mockI18nConfig: ModuleOptionsExtend
+  let setCookieMock: jest.Mock
+  let navigateToMock: jest.Mock
+
+  beforeEach(() => {
+    // Mock Router
+    mockRouter = {
+      currentRoute: { value: { params: { locale: 'en' } } },
+      resolve: jest.fn((to: RouteLocationRaw | string) => ({
+        fullPath: typeof to === 'string' ? to : to.path || '',
+        path: typeof to === 'string' ? to : to.path || '',
+        query: {},
+        hash: '',
+        params: {},
+      })) as unknown as jest.MockedFunction<Router['resolve']>,
+      hasRoute: jest.fn((_name: string) => false) as jest.MockedFunction<Router['hasRoute']>,
+      push: jest.fn(() => Promise.resolve()) as unknown as jest.MockedFunction<Router['push']>,
+    } as unknown as jest.Mocked<Router>
+
+    // Mock ModuleOptionsExtend
+    mockI18nConfig = {
+      apiBaseUrl: '',
+      dateBuild: 0,
+      disablePageLocales: false,
+      isSSG: false,
+      defaultLocale: 'en',
+      strategy: 'prefix_except_default',
+      locales: [
+        { code: 'en', iso: 'en-US' },
+        { code: 'de', iso: 'de-DE' },
+        { code: 'ru', iso: 'ru-RU' },
+      ],
+      hashMode: false,
+    }
+
+    // Mock setCookie and navigateTo
+    setCookieMock = jest.fn()
+    navigateToMock = jest.fn()
+
+    // Initialize RouteService
+    routeService = new RouteService(
+      mockI18nConfig,
+      mockRouter,
+      null,
+      null,
+      navigateToMock,
+      setCookieMock,
+      null,
+      null,
+    )
+  })
+
+  test('getCurrentLocale should return the correct locale', () => {
+    const locale = routeService.getCurrentLocale()
+    expect(locale).toBe('en')
+  })
+
+  test('getCurrentLocale should return the hash locale if hashMode is enabled', () => {
+    const mockI18nConfigWithHashMode = { ...mockI18nConfig, hashMode: true }
+    routeService = new RouteService(mockI18nConfigWithHashMode, mockRouter, 'de', null, navigateToMock, setCookieMock, null, null)
+    const locale = routeService.getCurrentLocale()
+    expect(locale).toBe('de')
+  })
+
+  test('getCurrentLocale should return the noPrefix locale if noPrefix strategy is enabled', () => {
+    const mockI18nConfigWithNoPrefix: ModuleOptionsExtend = { ...mockI18nConfig, strategy: 'no_prefix' }
+    routeService = new RouteService(mockI18nConfigWithNoPrefix, mockRouter, null, 'ru', navigateToMock, setCookieMock, null, null)
+    const locale = routeService.getCurrentLocale()
+    expect(locale).toBe('ru')
+  })
+
+  test('getCurrentName should return the display name of the current locale', () => {
+    const mockI18nConfigWithDisplayName = {
+      ...mockI18nConfig,
+      locales: [
+        { code: 'en', iso: 'en-US', displayName: 'English' },
+        { code: 'de', iso: 'de-DE', displayName: 'German' },
+        { code: 'ru', iso: 'ru-RU', displayName: 'Russian' },
+      ],
+    }
+    routeService = new RouteService(mockI18nConfigWithDisplayName, mockRouter, null, null, navigateToMock, setCookieMock, null, null)
+    const route = { name: 'localized-about-en' } as RouteLocationNormalizedLoaded
+    const displayName = routeService.getCurrentName(route)
+    expect(displayName).toBe('English')
+  })
+
+  test('getRouteName should return the correct route name without locale suffix', () => {
+    const route = { name: 'localized-about-en' } as RouteLocationNamedRaw
+    const routeName = routeService.getRouteName(route, 'en')
+    expect(routeName).toBe('about')
+  })
+
+  test('switchLocaleRoute should return the correct route for the new locale', () => {
+    const route = { name: 'localized-about-en', params: {} } as RouteLocationNamedRaw
+    const i18nRouteParams = { de: { param1: 'value1' } }
+    const newRoute = routeService.switchLocaleRoute('en', 'de', route, i18nRouteParams)
+    expect(newRoute).toEqual({
+      name: 'localized-about',
+      hash: undefined,
+      query: undefined,
+      params: { param1: 'value1', locale: 'de' },
+    })
+  })
+
+  test('getLocalizedRoute should return the correct localized route', () => {
+    const route = { name: 'about', params: {} } as RouteLocationNormalizedLoaded
+    const to = { path: '/about' } as RouteLocationResolvedGeneric
+    mockRouter.resolve.mockReturnValueOnce({
+      fullPath: '/en/about',
+      path: '/about',
+      query: {},
+      hash: '',
+      params: {},
+    } as RouteLocationResolvedGeneric)
+    const localizedRoute = routeService.getLocalizedRoute(to, route, 'en')
+    expect(localizedRoute).toEqual({
+      path: '/about',
+      fullPath: '/about',
+      query: {},
+      params: {},
+      hash: '',
+    })
+  })
+
+  test('switchLocaleLogic should switch the locale and navigate to the new route', async () => {
+    const route = { name: 'about-en', params: {} } as RouteLocationResolvedGeneric
+    const i18nRouteParams = { de: { param1: 'value1' } }
+    await routeService.switchLocaleLogic('de', i18nRouteParams, route)
+
+    // Check that push was called with correct arguments
+    expect(mockRouter.push).toHaveBeenCalledWith({
+      name: 'localized-about',
+      params: { param1: 'value1', locale: 'de' },
+      hash: undefined,
+      query: undefined,
+    })
+  })
+
+  test('getFullPathWithBaseUrl should return the correct full path with base URL', () => {
+    const currentLocale = { code: 'de', iso: 'de-DE', baseUrl: 'https://example.com/de' }
+    const route = { path: '/about' } as RouteLocationRaw
+    const fullPath = routeService.getFullPathWithBaseUrl(currentLocale, route)
+    expect(fullPath).toBe('https://example.com/de/about')
+  })
+
+  test('updateCookies should update cookies for hashMode and noPrefixStrategy', () => {
+    const mockI18nConfigWithHashMode: ModuleOptionsExtend = {
+      ...mockI18nConfig,
+      hashMode: true,
+      strategy: 'prefix_except_default',
+    }
+    routeService = new RouteService(mockI18nConfigWithHashMode, mockRouter, 'de', null, navigateToMock, setCookieMock, null, null)
+    routeService.updateCookies('de')
+    expect(setCookieMock).toHaveBeenCalledWith('hash-locale', 'de')
+
+    const mockI18nConfigWithNoPrefix: ModuleOptionsExtend = {
+      ...mockI18nConfig,
+      strategy: 'no_prefix',
+    }
+    routeService = new RouteService(mockI18nConfigWithNoPrefix, mockRouter, null, 'ru', navigateToMock, setCookieMock, null, null)
+    routeService.updateCookies('ru')
+    expect(setCookieMock).toHaveBeenCalledWith('no-prefix-locale', 'ru')
+  })
+
+  test('resolveLocalizedRoute should return the correct localized route', () => {
+    const to = { path: '/about' } as RouteLocationAsPathGeneric
+    mockRouter.resolve.mockReturnValueOnce({
+      fullPath: '/en/about',
+      path: '/about',
+      query: {},
+      hash: '',
+      params: {},
+    } as RouteLocationResolvedGeneric)
+    const localizedRoute = routeService.resolveLocalizedRoute(to, 'en')
+    expect(localizedRoute).toEqual({
+      path: '/about',
+      fullPath: '/about',
+      query: {},
+      params: {},
+      hash: '',
+    })
+  })
+
+  test('getCurrentLocale should return defaultLocale if locale is missing in route params', () => {
+    mockRouter.currentRoute.value.params = {} // Remove locale from params
+    mockRouter.currentRoute.value.path = '/' // No locale in path
+    const locale = routeService.getCurrentLocale()
+    expect(locale).toBe('en') // defaultLocale
+  })
+
+  test('getCurrentLocale should extract locale from URL path when route params are missing', () => {
+    mockRouter.currentRoute.value.params = {} // Remove locale from params
+    mockRouter.currentRoute.value.path = '/ru/sdfsdf' // URL with locale prefix
+    const locale = routeService.getCurrentLocale()
+    expect(locale).toBe('ru') // Should extract from URL
+  })
+
+  test('getCurrentLocale should use cookie locale when route params and URL path are missing', () => {
+    routeService = new RouteService(
+      mockI18nConfig,
+      mockRouter,
+      null,
+      null,
+      navigateToMock,
+      setCookieMock,
+      'de', // cookie locale
+      'user-locale', // cookie name
+    )
+    mockRouter.currentRoute.value.params = {} // Remove locale from params
+    mockRouter.currentRoute.value.path = '/' // No locale in path
+    const locale = routeService.getCurrentLocale()
+    expect(locale).toBe('de') // Should use cookie
+  })
+
+  test('getCurrentLocale should prioritize route params over URL path', () => {
+    mockRouter.currentRoute.value.params = { locale: 'de' } // Route params have locale
+    mockRouter.currentRoute.value.path = '/ru/sdfsdf' // URL has different locale
+    const locale = routeService.getCurrentLocale()
+    expect(locale).toBe('de') // Should use route params
+  })
+
+  test('getCurrentLocale should prioritize URL path over cookie', () => {
+    routeService = new RouteService(
+      mockI18nConfig,
+      mockRouter,
+      null,
+      null,
+      navigateToMock,
+      setCookieMock,
+      'de', // cookie locale
+      'user-locale', // cookie name
+    )
+    mockRouter.currentRoute.value.params = {} // No locale in params
+    mockRouter.currentRoute.value.path = '/ru/sdfsdf' // URL has locale
+    const locale = routeService.getCurrentLocale()
+    expect(locale).toBe('ru') // Should use URL path, not cookie
+  })
+
+  test('updateCookies should update cookie for regular strategy', () => {
+    routeService = new RouteService(
+      mockI18nConfig,
+      mockRouter,
+      null,
+      null,
+      navigateToMock,
+      setCookieMock,
+      null,
+      'user-locale', // cookie name
+    )
+    routeService.updateCookies('ru')
+    expect(setCookieMock).toHaveBeenCalledWith('user-locale', 'ru')
+  })
+
+  test('getCurrentName should return null if displayName is missing', () => {
+    const mockI18nConfigWithoutDisplayName = {
+      ...mockI18nConfig,
+      locales: [
+        { code: 'en', iso: 'en-US' }, // displayName is missing
+        { code: 'de', iso: 'de-DE' },
+        { code: 'ru', iso: 'ru-RU' },
+      ],
+    }
+    routeService = new RouteService(mockI18nConfigWithoutDisplayName, mockRouter, null, null, navigateToMock, setCookieMock, null, null)
+    const route = { name: 'localized-about-en' } as RouteLocationNormalizedLoaded
+    const displayName = routeService.getCurrentName(route)
+    expect(displayName).toBeNull()
+  })
+
+  test('switchLocaleRoute should handle missing i18nRouteParams', () => {
+    const route = { name: 'localized-about-en', params: {} } as RouteLocationResolvedGeneric
+    const newRoute = routeService.switchLocaleRoute('en', 'de', route, {})
+    expect(newRoute).toEqual({
+      name: 'localized-about',
+      hash: undefined,
+      query: undefined,
+      params: { locale: 'de' },
+    })
+  })
+
+  test('getFullPathWithBaseUrl should handle missing baseUrl', () => {
+    const currentLocale = { code: 'de', iso: 'de-DE' } // baseUrl is missing
+    const route = { path: '/about' } as RouteLocationRaw
+    const fullPath = routeService.getFullPathWithBaseUrl(currentLocale, route)
+    expect(fullPath).toBe('/about')
+  })
+
+  test('handlePrefixStrategy should handle invalid route', () => {
+    const to = '/invalid-route'
+    mockRouter.resolve.mockReturnValueOnce({
+      fullPath: '/invalid-route',
+      path: '/invalid-route',
+      query: {},
+      hash: '',
+      params: {},
+    } as RouteLocationResolvedGeneric)
+    const processedTo = routeService['handlePrefixStrategy'](to)
+    expect(processedTo).toEqual(to)
+  })
+
+  test('createLocalizedRoute should handle invalid route', () => {
+    const to = '/invalid-route'
+    const route = { name: 'about', params: {} } as RouteLocationNormalizedLoaded
+    mockRouter.resolve.mockReturnValueOnce({
+      fullPath: '/invalid-route',
+      path: '/invalid-route',
+      query: {},
+      hash: '',
+      params: {},
+    } as RouteLocationResolvedGeneric)
+    const localizedRoute = routeService['createLocalizedRoute'](to, route, 'en')
+    expect(localizedRoute).toEqual({
+      path: '/invalid-route',
+      fullPath: '/invalid-route',
+      query: {},
+      params: {},
+      hash: '',
+    })
+  })
+
+  test('resolveLocalizedRoute should handle invalid route', () => {
+    const to = '/invalid-route'
+    mockRouter.resolve.mockReturnValueOnce({
+      fullPath: '/invalid-route',
+      path: '/invalid-route',
+      query: {},
+      hash: '',
+      params: {},
+    } as RouteLocationResolvedGeneric)
+    const localizedRoute = routeService.resolveLocalizedRoute(to, 'en')
+    expect(localizedRoute).toEqual({
+      path: '/invalid-route',
+      fullPath: '/invalid-route',
+      query: {},
+      params: {},
+      hash: '',
+    })
+  })
+
+  test('updateCookies should not update cookies if hashMode and noPrefixStrategy are disabled', () => {
+    routeService.updateCookies('de')
+    expect(setCookieMock).not.toHaveBeenCalled()
+  })
+
+  test('getCurrentLocale should extract locale from fullPath with query params when route.path is missing', () => {
+    mockRouter.currentRoute.value.params = {}
+    mockRouter.currentRoute.value.path = '' // Simulate missing path (e.g. error state)
+    mockRouter.currentRoute.value.fullPath = '/de?foo=bar&baz=qux' // Fallback uses fullPath
+
+    // Ensure 'de' is in the config locales for this test
+    // (It is already present in mockI18nConfig in beforeEach)
+
+    const locale = routeService.getCurrentLocale()
+    expect(locale).toBe('de')
+  })
+
+  test('getCurrentLocale should extract locale from path with hash', () => {
+    mockRouter.currentRoute.value.params = {}
+    mockRouter.currentRoute.value.path = ''
+    mockRouter.currentRoute.value.fullPath = '/de#section'
+    const locale = routeService.getCurrentLocale()
+    expect(locale).toBe('de')
+  })
+})

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2018",
+    "module": "esnext",
+    "moduleResolution": "node",
+
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./dist",
+    "declaration": true,
+    "declarationDir": "./dist",
+    "sourceMap": true,
+    "rootDir": "./src",
+    "baseUrl": "./",
+    "paths": {
+      "*": ["node_modules/*", "src/types/*"]
+    },
+    "types": ["jest", "node"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/vite.config.mts

@@ -0,0 +1,25 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+import { resolve } from 'node:path'
+import { defineConfig } from 'vite'
+import dts from 'vite-plugin-dts'
+
+export default defineConfig({
+  build: {
+    lib: {
+      entry: resolve(__dirname, 'src/index.ts'),
+      name: '@i18n-micro/core',
+      formats: ['cjs', 'es'],
+      fileName: format => `index.${format === 'cjs' ? 'cjs' : 'mjs'}`,
+    },
+    rollupOptions: {
+      external: [],
+      output: {
+        exports: 'named',
+      },
+    },
+  },
+  plugins: [
+    dts(),
+  ],
+})