@i18n-micro/path-strategy 1.2.0 → 1.3.0

package/dist/index.d.ts

@@ -2,9 +2,10 @@ import { I18nRouteParams } from '@i18n-micro/types';
 import { Locale } from '@i18n-micro/types';
 import { Strategies } from '@i18n-micro/types';
 
+export declare function analyzeRoute(ctx: PathStrategyContext, route: ResolvedRouteLike): RouteAnalysis;
+
 export declare abstract class BasePathStrategy implements PathStrategy {
-    protected ctx: PathStrategyContext;
-    protected resolver: RouteResolver;
+    readonly ctx: PathStrategyContext;
     constructor(ctx: PathStrategyContext);
     setRouter(router: RouterAdapter): void;
     getDefaultLocale(): string;
@@ -15,142 +16,39 @@ export declare abstract class BasePathStrategy implements PathStrategy {
     getRouteLocales(): PathStrategyContext['routeLocales'];
     getRoutesLocaleLinks(): PathStrategyContext['routesLocaleLinks'];
     getNoPrefixRedirect(): boolean | undefined;
-    /**
-     * Returns base route name without locale prefix/suffix.
-     * @param route - Route object
-     * @param locale - Optional locale to strip suffix for (if not provided, tries all locales)
-     */
     getRouteBaseName(route: RouteLike, locale?: string): string | null;
-    /** Alias for internal use - strips localization prefix/suffix for specific locale. */
-    protected getBaseRouteName(route: RouteLike, locale: string): string | null;
-    /** Resolves target path for a locale, checking globalLocaleRoutes first. */
-    protected resolvePathForLocale(path: string, targetLocale: string): string;
-    protected buildLocalizedName(baseName: string, locale: string): string;
-    /** Builds path for target locale (strategy decides: with or without prefix). */
-    protected abstract buildLocalizedPath(path: string, locale: string, isCustom: boolean): string;
-    /** Builds localized route name for target locale. */
-    protected abstract buildLocalizedRouteName(baseName: string, locale: string): string;
-    protected getLocaleObject(code: string): Locale | undefined;
-    protected applyBaseUrl(localeCode: string, route: RouteLike | string): RouteLike | string;
-    /**
-     * Merges target route (strategy result) with query and hash from source route.
-     * Returns normalized RouteLike object.
-     */
-    protected preserveQueryAndHash(target: RouteLike | string, source?: RouteLike | null): RouteLike | string;
-    protected resolvePathWithParams(path: string, params?: Record<string, unknown>): string;
-    protected getPathWithoutLocaleAndBaseName(route: ResolvedRouteLike): {
-        pathWithoutLocale: string;
-        baseRouteName: string | null;
-    };
-    /** Look up custom path segment for targetLocale in globalLocaleRoutes. */
-    protected getCustomPathSegment(route: ResolvedRouteLike, targetLocale: string): string | null;
-    protected getAllowedLocalesForRoute(route: ResolvedRouteLike): string[];
-    getCanonicalPath(_route: ResolvedRouteLike, _targetLocale: string): string | null;
-    protected getPathForUnlocalizedRouteByName(routeName: string): string | null;
-    /**
-     * Try to resolve route by localized name. Returns RouteLike with query/hash from sourceRoute to preserve them.
-     */
-    protected tryResolveByLocalizedName(routeName: string, targetLocale: string, sourceRoute?: RouteLike): RouteLike | null;
-    /**
-     * Try to resolve route by localized name with params. Returns RouteLike to preserve query/hash.
-     */
-    protected tryResolveByLocalizedNameWithParams(routeName: string, targetLocale: string, params: Record<string, unknown>, sourceRoute?: RouteLike): RouteLike | null;
-    protected getPathForUnlocalizedRoute(route: ResolvedRouteLike): string | null;
-    /**
-     * Builds localized path from baseName + params when router does not have the route.
-     * Tries two conventions:
-     * 1) Hyphen form (Nuxt test-[id].vue → /test-:id): when single param key equals last baseName segment (e.g. test-id + id → test-:id).
-     * 2) Slash form (kebab→slash): path segments from baseName, last N replaced by :paramKey (e.g. test-id → /test/:id).
-     */
-    protected buildPathFromBaseNameAndParams(baseName: string, params: Record<string, unknown>, targetLocale: string): string | null;
-    protected getPathWithoutLocale(path: string): {
+    getBaseRouteName(route: RouteLike, locale: string): string | null;
+    buildLocalizedName(baseName: string, locale: string): string;
+    buildLocalizedRouteName(baseName: string, locale: string): string;
+    resolveLocaleFromPath(path: string): string | null;
+    detectLocaleFromName(name: string | null): string | null;
+    abstract switchLocaleRoute(fromLocale: string, toLocale: string, route: ResolvedRouteLike, options: SwitchLocaleOptions): RouteLike | string;
+    abstract resolveLocaleRoute(targetLocale: string, normalized: NormalizedRouteInput, _currentRoute?: ResolvedRouteLike): RouteLike | string;
+    abstract getRedirect(currentPath: string, targetLocale: string): string | null;
+    abstract getClientRedirect(currentPath: string, preferredLocale: string): string | null;
+    buildLocalizedPath(path: string, locale: string, _isCustom: boolean): string;
+    formatPathForResolve(path: string, fromLocale: string, _toLocale: string): string;
+    resolvePathForLocale(path: string, targetLocale: string): string;
+    getPathWithoutLocale(path: string): {
         pathWithoutLocale: string;
         localeFromPath: string | null;
     };
     getLocaleFromPath(path: string): string | null;
-    abstract resolveLocaleFromPath(path: string): string | null;
-    /**
-     * Returns path to redirect to, or null if no redirect needed.
-     * Use in middleware: strategy.getRedirect(to.fullPath, detectedLocale)
-     */
-    abstract getRedirect(currentPath: string, targetLocale: string): string | null;
-    /**
-     * Returns path to redirect to for client-side navigation based on preferred locale.
-     * Returns null if no redirect needed. Each strategy implements its own logic.
-     */
-    abstract getClientRedirect(currentPath: string, preferredLocale: string): string | null;
-    /**
-     * Checks if the current path should return 404.
-     * Returns error message if 404 should be returned, null otherwise.
-     * Base implementation checks unlocalized routes and routeLocales restrictions.
-     */
-    shouldReturn404(currentPath: string): string | null;
-    /**
-     * Builds SEO attributes (canonical + hreflangs) from current route.
-     * Respects routeLocales: only allowed locales for this route get an hreflang entry.
-     * routesLocaleLinks is used when resolving the route key for routeLocales lookup.
-     */
-    getSeoAttributes(currentRoute: ResolvedRouteLike): SeoAttributes;
-    /**
-     * Builds full URL (path + optional baseUrl for locale).
-     */
-    protected buildFullUrl(localeCode: string, path: string): string;
-    /** When router knows neither targetName nor baseName — what to return (strategy may override). */
-    protected getSwitchLocaleFallbackWhenNoRoute(route: ResolvedRouteLike, targetName: string): RouteLike | string;
-    /**
-     * Default: baseName → buildLocalizedRouteName → hasRoute → applyBaseUrl; fallback to baseName.
-     */
-    switchLocaleRoute(fromLocale: string, toLocale: string, route: ResolvedRouteLike, options: SwitchLocaleOptions): RouteLike | string;
-    /**
-     * Template Method: BaseStrategy knows "how" (normalize → delegate to strategy).
-     * Always returns RouteLike with path and fullPath (never a string).
-     */
+    getCanonicalPath(route: ResolvedRouteLike, targetLocale: string): string | null;
+    applyBaseUrl(localeCode: string, route: RouteLike | string): RouteLike | string;
+    getSwitchLocaleFallbackWhenNoRoute(route: ResolvedRouteLike, targetName: string): RouteLike | string;
     localeRoute(targetLocale: string, routeOrPath: RouteLike | string, currentRoute?: ResolvedRouteLike): RouteLike;
-    /** Normalizes resolveLocaleRoute result into RouteLike (path and fullPath always set). */
-    protected ensureRouteLike(value: RouteLike | string, source?: RouteLike | null): RouteLike;
-    /**
-     * Normalizes localeRoute input into a single structure (path string or route with resolved).
-     */
-    protected normalizeRouteInput(routeOrPath: RouteLike | string, _currentRoute?: ResolvedRouteLike): NormalizedRouteInput;
-    /** Logging when ctx.debug (for localeRoute debugging). Disabled by default. */
-    private debugLog;
-    /**
-     * Default resolution: uses buildLocalizedPath and buildLocalizedRouteName.
-     * Strategies with different logic (e.g. prefix-except-default) override this method.
-     */
-    protected resolveLocaleRoute(targetLocale: string, normalized: NormalizedRouteInput, _currentRoute?: ResolvedRouteLike): RouteLike | string;
-    /**
-     * Extracts locale from URL path by checking the first path segment.
-     */
-    private extractLocaleFromPath;
-    /**
-     * Determines current locale from route, considering hashMode, noPrefix, prefix_and_default at /, etc.
-     */
-    getCurrentLocale(route: ResolvedRouteLike, getDefaultLocale?: () => string | null | undefined): string;
-    /**
-     * Returns the route name for plugin translation loading.
-     * If disablePageLocales is true, returns 'index'.
-     */
+    _ensureRouteLike(value: RouteLike | string, source?: RouteLike | null): RouteLike;
+    _normalizeRouteInput(routeOrPath: RouteLike | string, _currentRoute?: ResolvedRouteLike): NormalizedRouteInput;
+    getCurrentLocale(route: ResolvedRouteLike, defaultLocaleOverride?: string | null): string;
     getPluginRouteName(route: ResolvedRouteLike, locale: string): string;
-    /**
-     * Returns displayName of the current locale, or null if not found.
-     */
-    getCurrentLocaleName(route: ResolvedRouteLike): string | null;
-    /**
-     * Formats path for router.resolve based on strategy.
-     * Each strategy should override this with its own logic.
-     */
-    abstract formatPathForResolve(path: string, fromLocale: string, toLocale: string): string;
+    getCurrentLocaleName(route: ResolvedRouteLike, defaultLocaleOverride?: string | null): string | null;
+    shouldReturn404(currentPath: string): string | null;
 }
 
 /** Builds localized name: localized-{baseName}-{locale}. */
 export declare function buildLocalizedName(baseName: string, locale: string, prefix?: string): string;
 
-/**
- * Creates localized route object preserving params, query, hash from source.
- */
-export declare function createLocalizedRouteObject(name: string | undefined, path: string, fullPath: string, source: RouteLike | ResolvedRouteLike, resolvedParams?: Record<string, unknown>, resolvedQuery?: Record<string, unknown>, resolvedHash?: string): RouteLike;
-
 /**
  * Creates the appropriate path strategy instance for the given context.
  * Used when all strategies are bundled (e.g. tests, server). For runtime client,
@@ -158,76 +56,43 @@ export declare function createLocalizedRouteObject(name: string | undefined, pat
  */
 export declare function createPathStrategy(ctx: PathStrategyContext): PathStrategy;
 
-/**
- * Determines locale from first path segment.
- */
-export declare function getLocaleFromPath(path: string, localeCodes: string[]): string | null;
-
-/**
- * Parses path: if first segment is a known locale, returns path without it and locale code.
- */
-export declare function getPathWithoutLocale(path: string, localeCodes: string[]): PathWithoutLocaleResult;
-
 /**
  * Base route name without prefix (localized-) and suffix (-{locale}).
- * Suffix is stripped only when it is a full segment (preceded by hyphen),
- * so names like product-screen are not broken when locale is en.
  */
-export declare function getRouteBaseName(route: RouteLike, options: GetRouteBaseNameOptions): string | null;
+export declare function getRouteBaseName(route: {
+    name?: string | null;
+} & Record<string, any>, options: GetRouteBaseNameOptions): string | null;
 
 export declare interface GetRouteBaseNameOptions {
-    locales: Pick<Locale, 'code'>[];
+    locales: {
+        code: string;
+    }[];
     localizedRouteNamePrefix?: string;
 }
 
 /** Custom path rules: route key -> locale -> path segment. false = unlocalized route. */
 export declare type GlobalLocaleRoutes = Record<string, Record<string, string> | false | boolean>;
 
-export declare interface HreflangTag {
-    rel: 'alternate';
-    href: string;
-    hreflang: string;
-}
-
 /**
- * Returns true if the given route name or base name refers to the index (root) route.
- * - Base name: 'index' or ''.
- * - Full route name: 'index', or 'localized-index-{locale}' for any locale in localeCodes.
- * Use this instead of ad-hoc checks like (name === 'index' || name.endsWith('-index') || name === 'localized-index-' + defaultLocale).
+ * Returns true if the given route name refers to the index (root) route.
  */
 export declare function isIndexRouteName(name: string | null | undefined, options?: IsIndexRouteNameOptions): boolean;
 
 export declare interface IsIndexRouteNameOptions {
     localizedRouteNamePrefix?: string;
-    localeCodes?: string[];
+    localeCodes?: readonly string[];
 }
 
 export declare class NoPrefixPathStrategy extends BasePathStrategy {
-    protected buildLocalizedPath(path: string, _locale: string, _isCustom: boolean): string;
-    protected buildLocalizedRouteName(baseName: string, locale: string): string;
+    buildLocalizedPath(path: string, _locale: string, _isCustom: boolean): string;
     getCanonicalPath(route: ResolvedRouteLike, targetLocale: string): string | null;
     resolveLocaleFromPath(_path: string): string | null;
-    getLocaleFromPath(path: string): string | null;
-    /** NoPrefix: when router does not know the route — return source route unchanged. */
-    protected getSwitchLocaleFallbackWhenNoRoute(route: ResolvedRouteLike, _targetName: string): RouteLike | string;
-    /**
-     * In no_prefix strategy, URL should not contain locale. If path starts with a locale segment,
-     * redirect to path without it. Controlled by ctx.noPrefixRedirect (default: true).
-     */
+    getSwitchLocaleFallbackWhenNoRoute(route: ResolvedRouteLike, _targetName: string): RouteLike | string;
+    switchLocaleRoute(fromLocale: string, toLocale: string, route: ResolvedRouteLike, options: SwitchLocaleOptions): RouteLike | string;
+    resolveLocaleRoute(targetLocale: string, normalized: NormalizedRouteInput, currentRoute?: ResolvedRouteLike): RouteLike | string;
     getRedirect(currentPath: string, _targetLocale: string): string | null;
-    /**
-     * Formats path for router.resolve.
-     * no_prefix: path as-is, no locale prefix.
-     */
     formatPathForResolve(path: string, _fromLocale: string, _toLocale: string): string;
-    /**
-     * no_prefix strategy: never redirect based on locale preference.
-     * Locale is handled via cookie/useState only, not URL.
-     */
     getClientRedirect(_currentPath: string, _preferredLocale: string): string | null;
-    /**
-     * no_prefix strategy: no 404 checks related to locale prefix.
-     */
     shouldReturn404(_currentPath: string): string | null;
 }
 
@@ -243,55 +108,21 @@ export declare type NormalizedRouteInput = {
 };
 
 export declare interface PathStrategy {
-    /**
-     * Returns a route object to navigate to another locale from the current page.
-     */
     switchLocaleRoute(fromLocale: string, toLocale: string, route: ResolvedRouteLike, options: SwitchLocaleOptions): RouteLike | string;
-    /**
-     * Localizes the given route (object or string) for the target locale.
-     * Always returns RouteLike (path and fullPath set). Analogue of $localeRoute / resolveLocalizedRoute.
-     */
     localeRoute(targetLocale: string, routeOrPath: RouteLike | string, currentRoute?: ResolvedRouteLike): RouteLike;
-    /**
-     * Checks if there is a custom path for the given route in globalLocaleRoutes.
-     * Used by redirect logic. Returns a path or null.
-     */
     getCanonicalPath(route: ResolvedRouteLike, targetLocale: string): string | null;
-    /**
-     * Determines locale from URL path (strategy-specific).
-     * Returns locale code or null if path does not contain a locale (e.g. no_prefix).
-     */
     resolveLocaleFromPath(path: string): string | null;
-    /**
-     * Tries to determine locale from URL path (first segment).
-     * Used for initial state and redirect logic. Base implementation in BasePathStrategy.
-     */
     getLocaleFromPath(path: string): string | null;
-    /**
-     * Returns path to redirect to for the given current path and target locale, or null if no redirect needed.
-     * Use in middleware: const redirectPath = strategy.getRedirect(to.fullPath, detectedLocale)
-     */
     getRedirect(currentPath: string, targetLocale: string): string | null;
-    /**
-     * Checks if the current path should return 404.
-     * Returns error message if 404 should be returned, null otherwise.
-     * Checks: invalid locale prefix, unlocalized routes with prefix, route locale restrictions.
-     */
     shouldReturn404(currentPath: string): string | null;
-    /**
-     * Returns path to redirect to for client-side navigation based on preferred locale.
-     * Returns null if no redirect needed.
-     * Used by client redirect plugin - each strategy implements its own logic.
-     */
     getClientRedirect(currentPath: string, preferredLocale: string): string | null;
-    /**
-     * Returns SEO attributes (canonical, hreflangs) for useHead.
-     */
-    getSeoAttributes(currentRoute: ResolvedRouteLike): SeoAttributes;
-    /**
-     * Sets the router adapter (e.g. when creating singleton and passing router later).
-     */
     setRouter(router: RouterAdapter): void;
+    /** Determines current locale from route (considers strategy, hashMode, params, path). */
+    getCurrentLocale(route: ResolvedRouteLike, defaultLocaleOverride?: string | null): string;
+    /** Returns the base route name for translation loading. */
+    getPluginRouteName(route: ResolvedRouteLike, locale: string): string;
+    /** Returns displayName of the current locale, or null. */
+    getCurrentLocaleName(route: ResolvedRouteLike, defaultLocaleOverride?: string | null): string | null;
     getDefaultLocale(): string;
     getLocales(): Locale[];
     getStrategy(): Strategies;
@@ -300,34 +131,7 @@ export declare interface PathStrategy {
     getRouteLocales(): Record<string, string[]> | undefined;
     getRoutesLocaleLinks(): Record<string, string> | undefined;
     getNoPrefixRedirect(): boolean | undefined;
-    /**
-     * Determines current locale from route, considering hashMode, noPrefix, etc.
-     * @param route - Current route object
-     * @param getDefaultLocale - Optional getter for locale state (for hashMode/noPrefix)
-     */
-    getCurrentLocale(route: ResolvedRouteLike, getDefaultLocale?: () => string | null | undefined): string;
-    /**
-     * Returns the route name for plugin translation loading.
-     * If disablePageLocales is true, returns 'index'.
-     */
-    getPluginRouteName(route: ResolvedRouteLike, locale: string): string;
-    /**
-     * Returns base route name without locale prefix/suffix.
-     * @param route - Route object
-     * @param locale - Optional locale to strip suffix for (if not provided, tries all locales)
-     */
     getRouteBaseName(route: RouteLike, locale?: string): string | null;
-    /**
-     * Returns displayName of the current locale, or null if not found.
-     */
-    getCurrentLocaleName(route: ResolvedRouteLike): string | null;
-    /**
-     * Formats path for router.resolve based on strategy.
-     * Returns path with or without locale prefix depending on strategy.
-     * @param path - Original path (e.g. '/about')
-     * @param fromLocale - Current locale
-     * @param toLocale - Target locale
-     */
     formatPathForResolve(path: string, fromLocale: string, toLocale: string): string;
 }
 
@@ -335,6 +139,8 @@ export declare interface PathStrategyContext {
     strategy: Strategies;
     defaultLocale: string;
     locales: Locale[];
+    /** Pre-computed locale codes (derived from locales). Set automatically at construction. */
+    localeCodes?: readonly string[];
     localizedRouteNamePrefix: string;
     globalLocaleRoutes?: GlobalLocaleRoutes;
     routeLocales?: Record<string, string[]>;
@@ -346,11 +152,10 @@ export declare interface PathStrategyContext {
     hashMode?: boolean;
     /** When true, all pages use only global translations (no page-specific loading) */
     disablePageLocales?: boolean;
-}
-
-export declare interface PathWithoutLocaleResult {
-    pathWithoutLocale: string;
-    localeFromPath: string | null;
+    /** Pre-computed: globalLocaleRoutes has at least one entry. Set automatically at construction. */
+    _hasGR?: boolean;
+    /** Pre-computed: routeLocales has at least one entry. Set automatically at construction. */
+    _hasRL?: boolean;
 }
 
 /**
@@ -358,86 +163,38 @@ export declare interface PathWithoutLocaleResult {
  * We use prefixed route names for consistency (localized-name-en).
  */
 export declare class PrefixAndDefaultPathStrategy extends BasePathStrategy {
-    protected buildLocalizedPath(path: string, locale: string, _isCustom: boolean): string;
-    protected buildLocalizedRouteName(baseName: string, locale: string): string;
     switchLocaleRoute(fromLocale: string, toLocale: string, route: ResolvedRouteLike, options: SwitchLocaleOptions): RouteLike | string;
-    protected resolveLocaleRoute(targetLocale: string, normalized: NormalizedRouteInput, currentRoute?: ResolvedRouteLike): RouteLike | string;
-    getCanonicalPath(route: ResolvedRouteLike, targetLocale: string): string | null;
-    protected detectLocaleFromName(name: string | null): string | null;
-    resolveLocaleFromPath(path: string): string | null;
+    private rewriteWithLocalePrefix;
+    resolveLocaleRoute(targetLocale: string, normalized: NormalizedRouteInput, currentRoute?: ResolvedRouteLike): RouteLike | string;
     getRedirect(currentPath: string, detectedLocale: string): string | null;
-    private buildPathWithPrefix;
-    /**
-     * Formats path for router.resolve.
-     * prefix_and_default: always add locale prefix.
-     */
-    formatPathForResolve(path: string, fromLocale: string, _toLocale: string): string;
-    /**
-     * prefix_and_default: both / and /locale are valid for any locale.
-     * Does NOT redirect if user explicitly navigates to a locale path.
-     * Only redirects from paths without locale prefix.
-     */
     getClientRedirect(currentPath: string, _preferredLocale: string): string | null;
 }
 
 export declare class PrefixExceptDefaultPathStrategy extends BasePathStrategy {
-    /**
-     * For this strategy a prefix is required for all non-default locales.
-     */
     protected shouldHavePrefix(locale: string): boolean;
-    protected buildLocalizedPath(path: string, locale: string, _isCustom: boolean): string;
-    protected buildLocalizedRouteName(baseName: string, locale: string): string;
+    buildLocalizedPath(path: string, locale: string, _isCustom: boolean): string;
+    buildLocalizedRouteName(baseName: string, locale: string): string;
     switchLocaleRoute(fromLocale: string, toLocale: string, route: ResolvedRouteLike, options: SwitchLocaleOptions): RouteLike | string;
-    protected resolveLocaleRoute(targetLocale: string, normalized: NormalizedRouteInput, currentRoute?: ResolvedRouteLike): RouteLike | string;
+    resolveLocaleRoute(targetLocale: string, normalized: NormalizedRouteInput, currentRoute?: ResolvedRouteLike): RouteLike | string;
+    private resolveLocaleRouteSimple;
+    private resolveLocaleRouteFull;
+    private resolveLocaleRouteFallback;
     getCanonicalPath(route: ResolvedRouteLike, targetLocale: string): string | null;
     resolveLocaleFromPath(path: string): string | null;
     getRedirect(currentPath: string, detectedLocale: string): string | null;
     shouldReturn404(currentPath: string): string | null;
-    /** True if gr[key] is a locale rules object (Record<locale, path>). */
     private isLocaleRules;
-    /**
-     * For a nested route name (e.g. activity-locale-hiking), returns parent key and slash-key
-     * when the route is nested (child or parent in globalLocaleRoutes). Otherwise null.
-     */
     private getNestedRouteInfo;
-    /** Parent path for target locale from gr or currentRoute. */
+    private buildNestedCustomResult;
     private getParentPathForTarget;
-    private buildPathWithPrefix;
-    /**
-     * Simple locale detector based on route name suffix.
-     * Looks for known locale codes at the end of the name.
-     */
-    protected detectLocaleFromName(name: string | null): string | null;
-    /**
-     * Formats path for router.resolve.
-     * prefix_except_default: add prefix only for non-default locale.
-     */
     formatPathForResolve(path: string, fromLocale: string, toLocale: string): string;
-    /**
-     * prefix_except_default: redirect based on preferred locale.
-     * Uses shouldHavePrefix to determine if locale needs prefix.
-     * Also handles custom paths from globalLocaleRoutes.
-     */
     getClientRedirect(currentPath: string, preferredLocale: string): string | null;
 }
 
 export declare class PrefixPathStrategy extends BasePathStrategy {
-    protected buildLocalizedPath(path: string, locale: string, _isCustom: boolean): string;
-    protected buildLocalizedRouteName(baseName: string, locale: string): string;
-    getCanonicalPath(route: ResolvedRouteLike, targetLocale: string): string | null;
-    resolveLocaleFromPath(path: string): string | null;
+    switchLocaleRoute(fromLocale: string, toLocale: string, route: ResolvedRouteLike, options: SwitchLocaleOptions): RouteLike | string;
+    resolveLocaleRoute(targetLocale: string, normalized: NormalizedRouteInput, currentRoute?: ResolvedRouteLike): RouteLike | string;
     getRedirect(currentPath: string, detectedLocale: string): string | null;
-    private buildPathWithPrefix;
-    /**
-     * Formats path for router.resolve.
-     * prefix: always add locale prefix.
-     */
-    formatPathForResolve(path: string, fromLocale: string, _toLocale: string): string;
-    /**
-     * prefix strategy: redirect only if URL has no locale prefix.
-     * Does NOT redirect if user explicitly navigates to a locale path.
-     * Uses custom paths from globalLocaleRoutes when available.
-     */
     getClientRedirect(currentPath: string, preferredLocale: string): string | null;
 }
 
@@ -448,8 +205,10 @@ export declare interface ResolvedRouteLike extends RouteLike {
     fullPath: string;
 }
 
-/** Input for localeRoute: path string or route-like object. */
-export declare type RouteInput = string | RouteLike;
+export declare interface RouteAnalysis {
+    pathWithoutLocale: string;
+    baseRouteName: string | null;
+}
 
 /** Route-like shape (compatible with vue-router). */
 export declare interface RouteLike {
@@ -467,54 +226,6 @@ export declare interface RouterAdapter {
     getRoutes?: () => unknown[];
 }
 
-export declare class RouteResolver {
-    private ctx;
-    constructor(ctx: PathStrategyContext);
-    /**
-     * Substitutes params into path template (:key, :key(), [...key]).
-     * Uses a single pre-compiled regex for all keys in one pass — no per-key RegExp allocation.
-     */
-    resolvePathWithParams(path: string, params?: Record<string, unknown>): string;
-    /**
-     * Analyzes route: path without locale and base name (normalizer + route-name).
-     */
-    private analyzeRoute;
-    /** Public access to route analysis (for strategies). */
-    getPathWithoutLocaleAndBaseName(route: ResolvedRouteLike): {
-        pathWithoutLocale: string;
-        baseRouteName: string | null;
-    };
-    /**
-     * Lookup keys for config (same order for resolveCustomPath, getPathForUnlocalizedRoute, getAllowedLocalesForRoute).
-     */
-    private getLookupKeys;
-    /**
-     * Resolves custom path for targetLocale from globalLocaleRoutes.
-     */
-    resolveCustomPath(route: ResolvedRouteLike, targetLocale: string): string | null;
-    /**
-     * Unlocalized route (globalLocaleRoutes[key] === false) — returns path without locale.
-     */
-    getPathForUnlocalizedRoute(route: ResolvedRouteLike): string | null;
-    /**
-     * Unlocalized by name (when no route object available).
-     */
-    getPathForUnlocalizedRouteByName(routeName: string): string | null;
-    /**
-     * Allowed locales for route (routeLocales).
-     */
-    getAllowedLocalesForRoute(route: ResolvedRouteLike): string[];
-    /**
-     * Parent path for nested route (parent key -> targetLocale path).
-     */
-    getParentPathForNested(nameSegments: string[], targetLocale: string): string;
-}
-
-export declare interface SeoAttributes {
-    canonical?: string;
-    hreflangs?: HreflangTag[];
-}
-
 export declare interface SwitchLocaleOptions {
     i18nRouteParams?: I18nRouteParams;
 }

package/dist/index.mjs

@@ -1,45 +1,32 @@
-import { B as x, R as w, m as R, o as S, q as _, r as L, d as N } from "./base-strategy-DDkINDnZ.js";
-import { NoPrefixPathStrategy as u } from "./no-prefix-strategy.mjs";
-import { PrefixPathStrategy as n } from "./prefix-strategy.mjs";
-import { PrefixAndDefaultPathStrategy as m } from "./prefix-and-default-strategy.mjs";
-import { PrefixExceptDefaultPathStrategy as a } from "./prefix-except-default-strategy.mjs";
-function d(e, r, o, t, f, i, s) {
-  return {
-    ...e ? { name: e } : {},
-    path: r,
-    fullPath: o,
-    params: f ?? t.params ?? {},
-    query: i ?? t.query ?? {},
-    hash: t.hash ?? s ?? ""
-  };
-}
-function g(e) {
+import { B as P, a as g, b as d, g as l, i as x } from "./base-strategy-CSEFam3u.js";
+import { NoPrefixPathStrategy as a } from "./no-prefix-strategy.mjs";
+import { PrefixPathStrategy as r } from "./prefix-strategy.mjs";
+import { PrefixAndDefaultPathStrategy as f } from "./prefix-and-default-strategy.mjs";
+import { PrefixExceptDefaultPathStrategy as t } from "./prefix-except-default-strategy.mjs";
+function s(e) {
   switch (e.strategy) {
     case "no_prefix":
-      return new u(e);
+      return new a(e);
     case "prefix":
-      return new n(e);
+      return new r(e);
     case "prefix_except_default":
-      return new a(e);
+      return new t(e);
     case "prefix_and_default":
-      return new m(e);
+      return new f(e);
     default:
-      return new a(e);
+      return new t(e);
   }
 }
 export {
-  x as BasePathStrategy,
-  u as NoPrefixPathStrategy,
-  m as PrefixAndDefaultPathStrategy,
-  a as PrefixExceptDefaultPathStrategy,
-  n as PrefixPathStrategy,
-  w as RouteResolver,
-  R as buildLocalizedName,
-  d as createLocalizedRouteObject,
-  g as createPathStrategy,
-  S as getLocaleFromPath,
-  _ as getPathWithoutLocale,
-  L as getRouteBaseName,
-  N as isIndexRouteName
+  P as BasePathStrategy,
+  a as NoPrefixPathStrategy,
+  f as PrefixAndDefaultPathStrategy,
+  t as PrefixExceptDefaultPathStrategy,
+  r as PrefixPathStrategy,
+  g as analyzeRoute,
+  d as buildLocalizedName,
+  s as createPathStrategy,
+  l as getRouteBaseName,
+  x as isIndexRouteName
 };
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":["../src/core/builder.ts","../src/strategies/factory.ts"],"sourcesContent":["/**\n * Pure functions for building route object (merge params, query, hash).\n */\nimport type { ResolvedRouteLike, RouteLike } from './types'\n\n/**\n * Creates localized route object preserving params, query, hash from source.\n */\nexport function createLocalizedRouteObject(\n  name: string | undefined,\n  path: string,\n  fullPath: string,\n  source: RouteLike | ResolvedRouteLike,\n  resolvedParams?: Record<string, unknown>,\n  resolvedQuery?: Record<string, unknown>,\n  resolvedHash?: string,\n): RouteLike {\n  return {\n    ...(name ? { name } : {}),\n    path,\n    fullPath,\n    params: resolvedParams ?? source.params ?? {},\n    query: resolvedQuery ?? source.query ?? {},\n    hash: source.hash ?? resolvedHash ?? '',\n  }\n}\n","import type { PathStrategy, PathStrategyContext } from '../core/types'\nimport { NoPrefixPathStrategy } from './no-prefix'\nimport { PrefixPathStrategy } from './prefix'\nimport { PrefixAndDefaultPathStrategy } from './prefix-and-default'\nimport { PrefixExceptDefaultPathStrategy } from './prefix-except-default'\n\n/**\n * Creates the appropriate path strategy instance for the given context.\n * Used when all strategies are bundled (e.g. tests, server). For runtime client,\n * use Nuxt alias #i18n-strategy to import only the selected strategy.\n */\nexport function createPathStrategy(ctx: PathStrategyContext): PathStrategy {\n  switch (ctx.strategy) {\n    case 'no_prefix':\n      return new NoPrefixPathStrategy(ctx)\n    case 'prefix':\n      return new PrefixPathStrategy(ctx)\n    case 'prefix_except_default':\n      return new PrefixExceptDefaultPathStrategy(ctx)\n    case 'prefix_and_default':\n      return new PrefixAndDefaultPathStrategy(ctx)\n    default:\n      return new PrefixExceptDefaultPathStrategy(ctx)\n  }\n}\n"],"names":["createLocalizedRouteObject","name","path","fullPath","source","resolvedParams","resolvedQuery","resolvedHash","createPathStrategy","ctx","NoPrefixPathStrategy","PrefixPathStrategy","PrefixExceptDefaultPathStrategy","PrefixAndDefaultPathStrategy"],"mappings":";;;;;AAQO,SAASA,EACdC,GACAC,GACAC,GACAC,GACAC,GACAC,GACAC,GACW;AACX,SAAO;AAAA,IACL,GAAIN,IAAO,EAAE,MAAAA,EAAA,IAAS,CAAA;AAAA,IACtB,MAAAC;AAAA,IACA,UAAAC;AAAA,IACA,QAAQE,KAAkBD,EAAO,UAAU,CAAA;AAAA,IAC3C,OAAOE,KAAiBF,EAAO,SAAS,CAAA;AAAA,IACxC,MAAMA,EAAO,QAAQG,KAAgB;AAAA,EAAA;AAEzC;ACdO,SAASC,EAAmBC,GAAwC;AACzE,UAAQA,EAAI,UAAA;AAAA,IACV,KAAK;AACH,aAAO,IAAIC,EAAqBD,CAAG;AAAA,IACrC,KAAK;AACH,aAAO,IAAIE,EAAmBF,CAAG;AAAA,IACnC,KAAK;AACH,aAAO,IAAIG,EAAgCH,CAAG;AAAA,IAChD,KAAK;AACH,aAAO,IAAII,EAA6BJ,CAAG;AAAA,IAC7C;AACE,aAAO,IAAIG,EAAgCH,CAAG;AAAA,EAAA;AAEpD;"}
+{"version":3,"file":"index.mjs","sources":["../src/strategies/factory.ts"],"sourcesContent":["import type { PathStrategy, PathStrategyContext } from '../types'\nimport { NoPrefixPathStrategy } from './no-prefix'\nimport { PrefixPathStrategy } from './prefix'\nimport { PrefixAndDefaultPathStrategy } from './prefix-and-default'\nimport { PrefixExceptDefaultPathStrategy } from './prefix-except-default'\n\n/**\n * Creates the appropriate path strategy instance for the given context.\n * Used when all strategies are bundled (e.g. tests, server). For runtime client,\n * use Nuxt alias #i18n-strategy to import only the selected strategy.\n */\nexport function createPathStrategy(ctx: PathStrategyContext): PathStrategy {\n  switch (ctx.strategy) {\n    case 'no_prefix':\n      return new NoPrefixPathStrategy(ctx)\n    case 'prefix':\n      return new PrefixPathStrategy(ctx)\n    case 'prefix_except_default':\n      return new PrefixExceptDefaultPathStrategy(ctx)\n    case 'prefix_and_default':\n      return new PrefixAndDefaultPathStrategy(ctx)\n    default:\n      return new PrefixExceptDefaultPathStrategy(ctx)\n  }\n}\n"],"names":["createPathStrategy","ctx","NoPrefixPathStrategy","PrefixPathStrategy","PrefixExceptDefaultPathStrategy","PrefixAndDefaultPathStrategy"],"mappings":";;;;;AAWO,SAASA,EAAmBC,GAAwC;AACzE,UAAQA,EAAI,UAAA;AAAA,IACV,KAAK;AACH,aAAO,IAAIC,EAAqBD,CAAG;AAAA,IACrC,KAAK;AACH,aAAO,IAAIE,EAAmBF,CAAG;AAAA,IACnC,KAAK;AACH,aAAO,IAAIG,EAAgCH,CAAG;AAAA,IAChD,KAAK;AACH,aAAO,IAAII,EAA6BJ,CAAG;AAAA,IAC7C;AACE,aAAO,IAAIG,EAAgCH,CAAG;AAAA,EAAA;AAEpD;"}

package/dist/no-prefix-strategy.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const l=require("./base-strategy-iCda2UF-.cjs");class o extends l.BasePathStrategy{buildLocalizedPath(e,r,t){return l.normalizePath(e)}buildLocalizedRouteName(e,r){return this.buildLocalizedName(e,r)}getCanonicalPath(e,r){const t=this.getCustomPathSegment(e,r);return t?t.startsWith("/")?t:`/${t}`:null}resolveLocaleFromPath(e){return null}getLocaleFromPath(e){return super.getLocaleFromPath(e)}getSwitchLocaleFallbackWhenNoRoute(e,r){return e}getRedirect(e,r){if(this.ctx.noPrefixRedirect===!1)return null;const t=this.getLocaleFromPath(e);if(!t)return null;const n=`/${t}`;let a=e.slice(n.length);return(!a||!a.startsWith("/"))&&(a=`/${a||""}`),l.cleanDoubleSlashes(a)||"/"}formatPathForResolve(e,r,t){return e}getClientRedirect(e,r){return null}shouldReturn404(e){return null}}exports.NoPrefixPathStrategy=o;exports.Strategy=o;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("./base-strategy-BHkH418r.cjs"),n=require("./common-sNHyO9pg.cjs");class u extends o.BasePathStrategy{buildLocalizedPath(e,r,t){return o.normalizePath(e)}getCanonicalPath(e,r){const t=o.resolveCustomPath(this.ctx,e,r)??"";return t?t.charCodeAt(0)===47?t:`/${t}`:null}resolveLocaleFromPath(e){return null}getSwitchLocaleFallbackWhenNoRoute(e,r){return e}switchLocaleRoute(e,r,t,l){return n.defaultSwitchLocaleRoute(this,e,r,t,l)}resolveLocaleRoute(e,r,t){return n.defaultResolveLocaleRoute(this,e,r)}getRedirect(e,r){if(this.ctx.noPrefixRedirect===!1)return null;const t=this.getLocaleFromPath(e);if(!t)return null;const l=`/${t}`;let a=e.slice(l.length);return(!a||a.charCodeAt(0)!==47)&&(a=`/${a||""}`),o.cleanDoubleSlashes(a)||"/"}formatPathForResolve(e,r,t){return e}getClientRedirect(e,r){return null}shouldReturn404(e){return null}}exports.NoPrefixPathStrategy=u;exports.Strategy=u;
 //# sourceMappingURL=no-prefix-strategy.cjs.map