@i18n-micro/path-strategy 1.1.3 → 1.3.0

package/dist/prefix-and-default-strategy.d.ts

@@ -3,8 +3,7 @@ import { Locale } from '@i18n-micro/types';
 import { Strategies } from '@i18n-micro/types';
 
 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,143 +14,39 @@ 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 'general'.
-     */
+    _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;
 }
 
 /** Custom path rules: route key -> locale -> path segment. false = unlocalized route. */
 declare type GlobalLocaleRoutes = Record<string, Record<string, string> | false | boolean>;
 
-declare interface HreflangTag {
-    rel: 'alternate';
-    href: string;
-    hreflang: string;
-}
-
 /** Normalized input for resolveLocaleRoute (template method). */
 declare type NormalizedRouteInput = {
     kind: 'path';
@@ -164,55 +59,21 @@ declare type NormalizedRouteInput = {
 };
 
 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;
@@ -221,34 +82,7 @@ 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 'general'.
-     */
-    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;
 }
 
@@ -256,6 +90,8 @@ 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[]>;
@@ -267,6 +103,10 @@ declare interface PathStrategyContext {
     hashMode?: boolean;
     /** When true, all pages use only global translations (no page-specific loading) */
     disablePageLocales?: boolean;
+    /** 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;
 }
 
 /**
@@ -274,25 +114,10 @@ declare interface PathStrategyContext {
  * We use prefixed route names for consistency (localized-name-en).
  */
 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 { PrefixAndDefaultPathStrategy }
@@ -321,54 +146,6 @@ declare interface RouterAdapter {
     getRoutes?: () => unknown[];
 }
 
-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;
-}
-
-declare interface SeoAttributes {
-    canonical?: string;
-    hreflangs?: HreflangTag[];
-}
-
 declare interface SwitchLocaleOptions {
     i18nRouteParams?: I18nRouteParams;
 }

package/dist/prefix-and-default-strategy.mjs

@@ -1,146 +1,96 @@
-import { B as F, j as i, n as U, h as u, k as R, d as v, t as S, w as q, a as w, g as C, i as k } from "./base-strategy-DmOQzfP1.js";
-class _ extends F {
-  buildLocalizedPath(t, e, a) {
-    return i(e, U(t));
-  }
-  buildLocalizedRouteName(t, e) {
-    return this.buildLocalizedName(t, e);
-  }
-  switchLocaleRoute(t, e, a, l) {
-    const h = this.getBaseRouteName(a, t);
-    if (!h) return a;
-    const o = this.buildLocalizedName(h, e), c = `${this.getLocalizedRouteNamePrefix()}${h}`;
-    let n, d = !1;
-    if (this.ctx.router.hasRoute(o))
-      n = o;
-    else if (this.ctx.router.hasRoute(c))
-      n = c, d = !0;
-    else if (this.ctx.router.hasRoute(h))
-      n = h;
+import { B as L, j as b, E as n, F as W, l as v, k as w, t as F, a as N, q as S, r as j, o as U, i as k, w as C, x as G, p as K, c as O } from "./base-strategy-CSEFam3u.js";
+class D extends L {
+  switchLocaleRoute(t, h, l, i) {
+    const e = this.getBaseRouteName(l, t);
+    if (!e) return l;
+    const a = this.getLocalizedRouteNamePrefix(), o = b(this.ctx.router, a, e, h);
+    let u, m = !1;
+    if (o)
+      u = o.name, m = o.needsLocaleParam;
+    else if (this.ctx.router.hasRoute(e))
+      u = e;
     else
-      return { ...a, name: o };
-    const p = l.i18nRouteParams?.[e] || {}, f = { ...a.params || {}, ...p };
-    return d ? f.locale = e : delete f.locale, this.applyBaseUrl(e, {
-      name: n,
-      params: f,
-      query: a.query,
-      hash: a.hash
+      return { ...l, name: this.buildLocalizedName(e, h) };
+    const c = i.i18nRouteParams?.[h] || {}, p = { ...l.params || {}, ...c };
+    return m ? p.locale = h : delete p.locale, this.applyBaseUrl(h, {
+      name: u,
+      params: p,
+      query: l.query,
+      hash: l.hash
     });
   }
-  resolveLocaleRoute(t, e, a) {
-    if (e.kind === "path") {
-      const s = this.resolvePathForLocale(e.path, t), r = `/${t}`;
-      return this.applyBaseUrl(t, i(r, u(s)));
+  rewriteWithLocalePrefix(t, h) {
+    const l = t.path ?? "", { pathWithoutLocale: i } = this.getPathWithoutLocale(l), e = n(i, h), a = W(e, t.query, t.hash);
+    return { ...t, path: e, fullPath: a };
+  }
+  resolveLocaleRoute(t, h, l) {
+    if (h.kind === "path") {
+      const s = this.resolvePathForLocale(h.path, t);
+      return this.applyBaseUrl(t, n(s, t));
     }
-    const { inputName: l, sourceRoute: h, resolved: o } = e;
-    if (l) {
-      const s = this.getPathForUnlocalizedRouteByName(l);
+    const { inputName: i, sourceRoute: e, resolved: a } = h, o = this.getLocalizedRouteNamePrefix();
+    if (i) {
+      const s = v(this.ctx, i);
       if (s !== null) return s;
     }
-    const c = h.params && Object.keys(h.params ?? {}).length > 0;
-    if (l && c) {
-      const s = this.tryResolveByLocalizedNameWithParams(l, t, h.params ?? {}, h);
-      if (s !== null) {
-        const r = s.path ?? "", { pathWithoutLocale: m } = this.getPathWithoutLocale(r), P = m === "/" || m === "" ? `/${t}` : i(`/${t}`, u(m)), W = R(P, s.query, s.hash), B = {
-          ...s,
-          path: P,
-          fullPath: W
-        };
-        return this.applyBaseUrl(t, B);
-      }
-    }
-    const n = this.getPathForUnlocalizedRoute(o);
-    if (n !== null) return this.applyBaseUrl(t, n);
-    const d = this.getCustomPathSegment(o, t);
-    if (d !== null) {
-      const s = `/${t}`;
-      return this.applyBaseUrl(t, i(s, u(d)));
+    const u = w(e.params);
+    if (i && u) {
+      const s = F(
+        this.ctx.router,
+        o,
+        i,
+        t,
+        e.params ?? {},
+        e
+      );
+      if (s !== null)
+        return this.applyBaseUrl(t, this.rewriteWithLocalePrefix(s, t));
     }
-    const p = this.getRouteBaseName(o) ?? l ?? o.name?.toString() ?? null;
-    if (l && !c) {
-      let s = this.tryResolveByLocalizedName(l, t, h);
-      const r = this.getLocalizedRouteNamePrefix();
-      if (s === null && p != null && p !== l && l.startsWith(r) && (s = this.tryResolveByLocalizedName(p, t, h)), s !== null) {
-        const m = s.path ?? "", { pathWithoutLocale: P } = this.getPathWithoutLocale(m), W = P === "/" || P === "" ? `/${t}` : i(`/${t}`, u(P)), B = R(W, s.query, s.hash), g = {
-          ...s,
-          path: W,
-          fullPath: B
-        };
-        return this.applyBaseUrl(t, g);
+    const m = this.ctx._hasGR === !0, c = this.getRouteBaseName(a) ?? i ?? a.name?.toString() ?? null;
+    if (m) {
+      const s = N(this.ctx, a), r = S(this.ctx, a, s);
+      if (r !== null) return this.applyBaseUrl(t, r);
+      const P = j(this.ctx, a, t, s);
+      if (P !== null)
+        return this.applyBaseUrl(t, n(P, t));
+      if (a.path && a.path !== "/" && a.name) {
+        const { pathWithoutLocale: x } = s;
+        if (x && x !== "/")
+          return this.applyBaseUrl(t, n(x, t));
       }
     }
-    if (o.path && o.path !== "/" && o.name) {
-      const { pathWithoutLocale: s } = this.getPathWithoutLocaleAndBaseName(o);
-      if (s && s !== "/")
-        return this.applyBaseUrl(t, i(`/${t}`, u(s)));
+    if (i && !u) {
+      let s = U(this.ctx.router, o, i, t, e);
+      if (s === null && c != null && c !== i && i.startsWith(o) && (s = U(this.ctx.router, o, c, t, e)), s !== null)
+        return this.applyBaseUrl(t, this.rewriteWithLocalePrefix(s, t));
+    }
+    if (!m && a.path && a.path !== "/" && a.name) {
+      const s = N(this.ctx, a), { pathWithoutLocale: r } = s;
+      if (r && r !== "/")
+        return this.applyBaseUrl(t, n(r, t));
     }
-    const f = a ? this.detectLocaleFromName(a.name) : this.detectLocaleFromName(o.name), y = f ? this.getBaseRouteName(o, f) : p;
-    if (!y) {
-      const { pathWithoutLocale: s } = this.getPathWithoutLocale(o.path ?? "/"), r = s === "/" || s === "" ? `/${t}` : i(`/${t}`, u(s)), m = R(r, h.query, h.hash);
+    const p = this.detectLocaleFromName(l ? l.name : a.name), f = p ? this.getBaseRouteName(a, p) : c;
+    if (!f) {
+      const { pathWithoutLocale: s } = this.getPathWithoutLocale(a.path ?? "/"), r = n(s, t), P = W(r, e.query, e.hash);
       return this.applyBaseUrl(t, {
-        ...h,
+        ...e,
         path: r,
-        fullPath: m
+        fullPath: P
       });
     }
-    const $ = this.buildLocalizedName(y, t), z = v(y) ? "/" : i("/", S(y)), L = i(`/${t}`, u(z)), N = this.applyBaseUrl(t, L), x = typeof N == "string" ? N : N.path ?? L, b = {
-      name: $,
-      path: x,
-      fullPath: x,
-      params: { ...o.params, ...h.params },
-      query: { ...o.query, ...h.query },
-      hash: h.hash ?? o.hash
-    };
-    return this.applyBaseUrl(t, b);
-  }
-  getCanonicalPath(t, e) {
-    const a = this.getCustomPathSegment(t, e);
-    return a ? i(`/${e}`, u(a)) : null;
-  }
-  detectLocaleFromName(t) {
-    if (!t) return null;
-    for (const e of this.ctx.locales)
-      if (t.endsWith(`-${e.code}`))
-        return e.code;
-    return null;
-  }
-  resolveLocaleFromPath(t) {
-    const { localeFromPath: e } = this.getPathWithoutLocale(t);
-    return e;
-  }
-  getRedirect(t, e) {
-    const { pathWithoutLocale: a, localeFromPath: l } = this.getPathWithoutLocale(t), h = this.ctx.globalLocaleRoutes;
-    if (h && l !== null) {
-      const n = a === "/" ? "/" : q(a);
-      if (h[a] === !1 || h[n] === !1)
-        return w(a === "/" ? "/" : a);
-    }
-    const o = this.buildPathWithPrefix(a, e), c = C(t);
-    return l === e && k(c, o) ? null : o;
-  }
-  buildPathWithPrefix(t, e) {
-    const a = this.resolvePathForLocale(t, e);
-    return a === "/" || a === "" ? `/${e}` : i(`/${e}`, a);
+    const q = this.buildLocalizedName(f, t), z = k(f) ? "/" : C("/", G(f)), R = n(z, t), d = this.applyBaseUrl(t, R), B = typeof d == "string" ? d : d.path ?? R, y = { name: q, path: B, fullPath: B };
+    return (a.params || e.params) && (y.params = a.params !== e.params ? Object.assign({}, a.params, e.params) : a.params), (a.query || e.query) && (y.query = a.query !== e.query ? Object.assign({}, a.query, e.query) : a.query), y.hash = e.hash || a.hash, this.applyBaseUrl(t, y);
   }
-  /**
-   * Formats path for router.resolve.
-   * prefix_and_default: always add locale prefix.
-   */
-  formatPathForResolve(t, e, a) {
-    return `/${e}${t}`;
+  getRedirect(t, h) {
+    return K(this, t, h);
   }
-  /**
-   * 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(t, e) {
-    const { pathWithoutLocale: a, localeFromPath: l } = this.getPathWithoutLocale(t), h = this.ctx.globalLocaleRoutes, o = a === "/" ? "/" : a.replace(/^\//, "");
-    return h && (h[a] === !1 || h[o] === !1) || l !== null || t === "/" || t === "", null;
+  getClientRedirect(t, h) {
+    const { pathWithoutLocale: l, localeFromPath: i } = this.getPathWithoutLocale(t);
+    return O(l, this.ctx.globalLocaleRoutes) || i !== null, null;
   }
 }
 export {
-  _ as PrefixAndDefaultPathStrategy,
-  _ as Strategy
+  D as PrefixAndDefaultPathStrategy,
+  D as Strategy
 };
 //# sourceMappingURL=prefix-and-default-strategy.mjs.map