@i18n-micro/core 1.0.28 → 1.1.1

package/src/route-service.ts

@@ -1,474 +0,0 @@
-import type {
-  NavigationFailure,
-  RouteLocationAsPath, RouteLocationAsPathGeneric,
-  RouteLocationAsRelative,
-  RouteLocationAsString,
-  RouteLocationNamedRaw,
-  RouteLocationNormalizedLoaded,
-  RouteLocationOptions,
-  RouteLocationRaw,
-  RouteLocationResolved,
-  RouteLocationResolvedGeneric,
-  RouteParamsRawGeneric,
-  Router,
-} from 'vue-router'
-import type { I18nRouteParams, Locale, ModuleOptionsExtend } from '@i18n-micro/types'
-import { isNoPrefixStrategy, withPrefixStrategy } from './helpers'
-
-interface NavigateToInterface {
-  replace?: boolean
-  redirectCode?: number
-  external?: boolean
-}
-
-export class RouteService {
-  constructor(
-    private i18nConfig: ModuleOptionsExtend,
-    private router: Router,
-    private hashLocaleDefault: string | null | undefined,
-    private noPrefixDefault: string | null | undefined,
-    private navigateTo: (to: RouteLocationRaw | undefined | null, options?: NavigateToInterface) => Promise<void | NavigationFailure | false> | false | void | RouteLocationRaw,
-    private setCookie: (name: string, value: string) => void,
-    private cookieLocaleDefault: string | null | undefined = null,
-    private cookieLocaleName: string | null | undefined = null,
-  ) {}
-
-  /**
-   * Extracts locale from URL path by checking the first path segment
-   * @param path - URL path (e.g., '/ru/sdfsdf' or '/en/about')
-   * @returns Locale code or null if not found
-   */
-  private extractLocaleFromPath(path: string): string | null {
-    if (!path) {
-      return null
-    }
-
-    // Remove query params and hash to ensure clean path comparison
-    // This is important when falling back to fullPath which might contain these
-    const querySplit = path.split('?')
-    const cleanPath = querySplit[0]?.split('#')[0]
-
-    if (!cleanPath || cleanPath === '/') {
-      return null
-    }
-
-    const pathSegments = cleanPath.split('/').filter(Boolean)
-    if (pathSegments.length === 0) {
-      return null
-    }
-
-    const firstSegment = pathSegments[0]
-    if (!firstSegment) {
-      return null
-    }
-
-    const availableLocales = this.i18nConfig.locales?.map(l => l.code) || []
-
-    // Check if the first segment is a valid locale
-    if (availableLocales.includes(firstSegment)) {
-      return firstSegment
-    }
-
-    return null
-  }
-
-  getCurrentLocale(route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric): string {
-    route = route ?? this.router.currentRoute.value
-
-    // 1. Check hashMode
-    if (this.i18nConfig.hashMode && this.hashLocaleDefault) {
-      return this.hashLocaleDefault
-    }
-
-    // 2. Check noPrefix strategy
-    if (isNoPrefixStrategy(this.i18nConfig.strategy!) && this.noPrefixDefault) {
-      return this.noPrefixDefault
-    }
-
-    // 3. Check route.params.locale (for existing routes)
-    if (route.params?.locale) {
-      return route.params.locale.toString()
-    }
-
-    // 4. Extract locale from URL path (for non-existent routes)
-    const path = route.path || route.fullPath || ''
-    const localeFromPath = this.extractLocaleFromPath(path)
-    if (localeFromPath) {
-      return localeFromPath
-    }
-
-    // 5. Check cookie (if provided)
-    if (this.cookieLocaleDefault) {
-      return this.cookieLocaleDefault
-    }
-
-    // 6. Return defaultLocale as fallback
-    return (this.i18nConfig.defaultLocale || 'en').toString()
-  }
-
-  getCurrentName(route: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric): string | null {
-    const currentLocaleCode = this.getCurrentLocale(route)
-    const checkLocale = this.i18nConfig.locales?.find(l => l.code === currentLocaleCode)
-    return checkLocale?.displayName ?? null
-  }
-
-  getRouteName(route: RouteLocationResolvedGeneric | RouteLocationNamedRaw, locale: string): string {
-    const name = (route.name ?? '').toString()
-    return name
-      .toString()
-      .replace('localized-', '')
-      .replace(new RegExp(`-${locale}$`), '')
-  }
-
-  getPluginRouteName(route: RouteLocationResolvedGeneric | RouteLocationNamedRaw, locale: string): string {
-    if (this.i18nConfig.disablePageLocales) {
-      return 'general'
-    }
-    return this.getRouteName(route, locale)
-  }
-
-  getFullPathWithBaseUrl(currentLocale: Locale, route: RouteLocationRaw): string {
-    const resolvedRoute = this.router.resolve(route)
-    let fullPath = resolvedRoute.fullPath
-
-    if (currentLocale?.baseDefault) {
-      fullPath = fullPath.replace(new RegExp(`^/${currentLocale!.code}`), '')
-    }
-
-    let baseUrl = currentLocale!.baseUrl
-    if (!baseUrl) baseUrl = ''
-    if (baseUrl?.endsWith('/')) {
-      baseUrl = baseUrl.slice(0, -1)
-    }
-
-    return baseUrl + fullPath
-  }
-
-  switchLocaleRoute(
-    fromLocale: string,
-    toLocale: string,
-    route: RouteLocationResolvedGeneric | RouteLocationNamedRaw,
-    i18nRouteParams: I18nRouteParams,
-  ): RouteLocationRaw {
-    const currentLocale = this.i18nConfig.locales?.find(l => l.code === toLocale)
-
-    const routeName = this.getRouteName(route, fromLocale)
-    if (this.router.hasRoute(`localized-${routeName}-${toLocale}`)) {
-      // If i18nRouteParams exist for target locale, use them as base, otherwise use route.params
-      const baseParams = i18nRouteParams?.[toLocale]
-        ? { ...i18nRouteParams[toLocale] }
-        : { ...route.params ?? {} }
-      // Merge remaining route.params that are not in i18nRouteParams
-      const newParams = { ...baseParams }
-      // Remove locale from params if it exists, we'll add it explicitly
-      delete newParams.locale
-      if (!isNoPrefixStrategy(this.i18nConfig.strategy!)) newParams.locale = toLocale
-
-      const newRoute = {
-        name: `localized-${routeName}-${toLocale}`,
-        params: newParams,
-        query: route.query,
-        hash: route.hash,
-      }
-
-      if (currentLocale?.baseUrl) {
-        return this.getFullPathWithBaseUrl(currentLocale, newRoute)
-      }
-
-      return newRoute
-    }
-
-    let newRouteName = routeName
-    // If i18nRouteParams exist for target locale, use them as base, otherwise use route.params
-    const baseParams = i18nRouteParams?.[toLocale]
-      ? { ...i18nRouteParams[toLocale] }
-      : { ...route.params ?? {} }
-    // Merge remaining route.params that are not in i18nRouteParams
-    const newParams = { ...baseParams }
-    delete newParams.locale
-
-    if (!isNoPrefixStrategy(this.i18nConfig.strategy!)) {
-      if (routeName === 'custom-fallback-route') {
-        newRouteName = routeName
-      }
-      else {
-        newRouteName
-          = toLocale !== this.i18nConfig.defaultLocale || withPrefixStrategy(this.i18nConfig.strategy!)
-            ? `localized-${routeName}`
-            : routeName
-      }
-
-      if (!isNoPrefixStrategy(this.i18nConfig.strategy!)) {
-        if (toLocale !== this.i18nConfig.defaultLocale || withPrefixStrategy(this.i18nConfig.strategy!)) {
-          newParams.locale = toLocale
-        }
-      }
-    }
-
-    const newRoute = {
-      name: newRouteName,
-      params: newParams,
-      query: route.query,
-      hash: route.hash,
-    }
-
-    if (isNoPrefixStrategy(this.i18nConfig.strategy!)) {
-      this.i18nConfig.locales?.forEach((locale, _index) => {
-        if (newRoute.name.endsWith(`-${locale.code}`)) {
-          newRoute.name = newRoute.name.slice(0, -locale.code - 1)
-        }
-      })
-    }
-
-    if (currentLocale?.baseUrl) {
-      return this.getFullPathWithBaseUrl(currentLocale, newRoute)
-    }
-
-    return newRoute
-  }
-
-  private resolveParams(to: RouteLocationAsString | RouteLocationAsRelative | RouteLocationAsPath): RouteParamsRawGeneric {
-    const params
-      = typeof to === 'object' && 'params' in to && typeof to.params === 'object'
-        ? { ...to.params }
-        : {}
-
-    if (typeof to === 'string') {
-      const resolved = this.router.resolve(to)
-      if (resolved && resolved.params) {
-        Object.assign(params, resolved.params)
-      }
-    }
-
-    return params
-  }
-
-  private handlePrefixStrategy(
-    to: RouteLocationResolvedGeneric | RouteLocationAsPathGeneric | RouteLocationNamedRaw | string,
-  ): RouteLocationResolvedGeneric | RouteLocationAsPathGeneric | RouteLocationNamedRaw | string {
-    if (!withPrefixStrategy(this.i18nConfig.strategy!)) {
-      return to
-    }
-
-    const defaultLocale = this.i18nConfig.defaultLocale!
-    let resolvedTo = to
-
-    if (typeof to === 'string') {
-      resolvedTo = this.router.resolve('/' + defaultLocale + to)
-    }
-
-    const defaultRouteName = this.getRouteName(resolvedTo as RouteLocationResolvedGeneric, defaultLocale)
-    const newParams = this.resolveParams(resolvedTo)
-
-    if (!isNoPrefixStrategy(this.i18nConfig.strategy!)) {
-      newParams.locale = defaultLocale
-    }
-
-    if (this.router.hasRoute(`localized-${defaultRouteName}`)) {
-      return this.router.resolve({
-        name: `localized-${defaultRouteName}`,
-        query: (resolvedTo as RouteLocationNormalizedLoaded).query,
-        hash: (resolvedTo as RouteLocationNormalizedLoaded).hash,
-        params: newParams,
-      })
-    }
-    else if (this.router.hasRoute(`localized-${defaultRouteName}-${defaultLocale}`)) {
-      return this.router.resolve({
-        name: `localized-${defaultRouteName}-${defaultLocale}`,
-        query: (resolvedTo as RouteLocationNormalizedLoaded).query,
-        hash: (resolvedTo as RouteLocationNormalizedLoaded).hash,
-        params: newParams,
-      })
-    }
-
-    return to
-  }
-
-  private createLocalizedRoute(
-    to: RouteLocationAsString | RouteLocationAsRelative | RouteLocationAsPath,
-    route: RouteLocationNormalizedLoaded,
-    locale: string,
-  ): RouteLocationResolved {
-    const selectRoute = this.router.resolve(to)
-    const routeName = this.getRouteName(selectRoute, locale)
-      .replace(new RegExp(`-${this.i18nConfig.defaultLocale!}$`), '')
-
-    if (!isNoPrefixStrategy(this.i18nConfig.strategy!)) {
-      if (!routeName || routeName === '') {
-        const resolved = this.router.resolve(to)
-        let url = resolved.path.replace(new RegExp(`^/${locale}/`), '/')
-        if (locale !== this.i18nConfig.defaultLocale || withPrefixStrategy(this.i18nConfig.strategy!)) {
-          url = '/' + locale + '' + url
-        }
-
-        return this.router.resolve({
-          path: url,
-          query: selectRoute.query,
-          hash: selectRoute.hash,
-        })
-      }
-    }
-
-    if (this.router.hasRoute(`localized-${routeName}-${locale}`)) {
-      const newParams = this.resolveParams(selectRoute)
-      if (!isNoPrefixStrategy(this.i18nConfig.strategy!)) newParams.locale = locale
-
-      return this.router.resolve({
-        name: `localized-${routeName}-${locale}`,
-        params: newParams,
-        query: selectRoute.query,
-        hash: selectRoute.hash,
-      })
-    }
-
-    const newRouteName
-      = locale !== this.i18nConfig.defaultLocale || withPrefixStrategy(this.i18nConfig.strategy!)
-        ? `localized-${routeName}`
-        : routeName
-
-    if (!this.router.hasRoute(newRouteName)) {
-      const newParams = this.resolveParams(to)
-      delete newParams.locale
-
-      if (!this.router.hasRoute(routeName)) {
-        return this.router.resolve('/')
-      }
-
-      return this.router.resolve({
-        name: routeName,
-        params: newParams,
-        query: selectRoute.query,
-        hash: selectRoute.hash,
-      })
-    }
-
-    const newParams = this.resolveParams(to)
-    delete newParams.locale
-
-    if (!isNoPrefixStrategy(this.i18nConfig.strategy!)) {
-      if (locale !== this.i18nConfig.defaultLocale || withPrefixStrategy(this.i18nConfig.strategy!)) {
-        newParams.locale = locale
-      }
-    }
-
-    return this.router.resolve({
-      name: newRouteName,
-      params: newParams,
-      query: selectRoute.query,
-      hash: selectRoute.hash,
-    })
-  }
-
-  getLocalizedRoute(
-    to: RouteLocationResolvedGeneric | RouteLocationAsPathGeneric | RouteLocationNamedRaw | string,
-    route: RouteLocationNormalizedLoaded,
-    locale?: string,
-  ): RouteLocationResolved {
-    const currentLocale = locale || this.getCurrentLocale(route)
-
-    // Handle prefix strategy
-    const processedTo = this.handlePrefixStrategy(to)
-
-    // Create localized route
-    return this.createLocalizedRoute(processedTo, route, currentLocale)
-  }
-
-  updateCookies(toLocale: string): void {
-    const cookieLocaleName = this.cookieLocaleName || this.i18nConfig.localeCookie || 'user-locale'
-    if (this.i18nConfig.hashMode) {
-      this.setCookie('hash-locale', toLocale)
-      // useCookie('hash-locale').value = toLocale
-      this.hashLocaleDefault = toLocale
-    }
-    if (isNoPrefixStrategy(this.i18nConfig.strategy!)) {
-      this.setCookie(cookieLocaleName, toLocale)
-      // useCookie(cookieLocaleName).value = toLocale
-      this.noPrefixDefault = toLocale
-    }
-    // Update cookie for regular strategy (prefix or prefix_except_default)
-    if (!this.i18nConfig.hashMode && !isNoPrefixStrategy(this.i18nConfig.strategy!) && cookieLocaleName) {
-      this.setCookie(cookieLocaleName, toLocale)
-      this.cookieLocaleDefault = toLocale
-    }
-  }
-
-  getCurrentRoute(): RouteLocationNormalizedLoaded {
-    return this.router.currentRoute.value
-  }
-
-  private resolveRouteWithStrategy(
-    route: string,
-    currentLocale: string,
-    fromLocale: string,
-  ): RouteLocationResolved {
-    if (isNoPrefixStrategy(this.i18nConfig.strategy!)) {
-      return this.router.resolve(route)
-    }
-    else if (currentLocale !== this.i18nConfig.defaultLocale || withPrefixStrategy(this.i18nConfig.strategy!)) {
-      return this.router.resolve(`/${fromLocale}${route}`)
-    }
-    else {
-      return this.router.resolve(route)
-    }
-  }
-
-  switchLocaleLogic(toLocale: string, i18nRouteParams: I18nRouteParams, to?: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string) {
-    const fromLocale = this.getCurrentLocale()
-
-    let current: RouteLocationResolved | RouteLocationNamedRaw
-    if (typeof to === 'string') {
-      current = this.resolveRouteWithStrategy(to, toLocale, fromLocale)
-    }
-    else {
-      current = to ?? this.getCurrentRoute() as RouteLocationResolved
-    }
-
-    this.updateCookies(toLocale)
-    const switchedRoute = this.switchLocaleRoute(fromLocale, toLocale, current, i18nRouteParams)
-
-    if (typeof switchedRoute === 'string' && switchedRoute.startsWith('http')) {
-      return this.navigateTo(switchedRoute, { redirectCode: 200, external: true })
-    }
-
-    if (isNoPrefixStrategy(this.i18nConfig.strategy!)) {
-      (switchedRoute as RouteLocationRaw & RouteLocationOptions).force = true
-    }
-
-    return this.router.push(switchedRoute)
-  }
-
-  resolveLocalizedRoute(
-    to: RouteLocationNamedRaw | RouteLocationAsPathGeneric | string,
-    locale?: string,
-  ): RouteLocationResolved {
-    const currentRoute = this.getCurrentRoute()
-    const fromLocale = this.getCurrentLocale()
-    const currentLocale = locale ?? fromLocale
-
-    let current: RouteLocationResolved | RouteLocationNamedRaw | RouteLocationAsPathGeneric
-    if (typeof to === 'string') {
-      // Try to resolve as route name first (if it doesn't start with / and exists as route name)
-      if (!to.startsWith('/')) {
-        const routeName = to
-        // Check if this is a route name (not a path)
-        if (this.router.hasRoute(routeName)) {
-          // Resolve by name to get the correct route object
-          current = this.router.resolve({ name: routeName })
-        }
-        else {
-          // Treat as path
-          to = `/${to}`
-          current = this.resolveRouteWithStrategy(to, currentLocale, fromLocale)
-        }
-      }
-      else {
-        current = this.resolveRouteWithStrategy(to, currentLocale, fromLocale)
-      }
-    }
-    else {
-      current = to
-    }
-
-    return this.getLocalizedRoute(current, currentRoute, currentLocale)
-  }
-}