@i18n-micro/path-strategy 1.0.0

package/dist/index.mjs

@@ -0,0 +1,45 @@
+import { B as x, R as w, m as R, o as S, q as _, r as L, d as N } from "./base-strategy-DVqe8ehd.js";
+import { PrefixPathStrategy as u } from "./prefix-strategy.mjs";
+import { NoPrefixPathStrategy as n } from "./no-prefix-strategy.mjs";
+import { PrefixExceptDefaultPathStrategy as a } from "./prefix-except-default-strategy.mjs";
+import { PrefixAndDefaultPathStrategy as m } from "./prefix-and-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) {
+  switch (e.strategy) {
+    case "no_prefix":
+      return new n(e);
+    case "prefix":
+      return new u(e);
+    case "prefix_except_default":
+      return new a(e);
+    case "prefix_and_default":
+      return new m(e);
+    default:
+      return new a(e);
+  }
+}
+export {
+  x as BasePathStrategy,
+  n as NoPrefixPathStrategy,
+  m as PrefixAndDefaultPathStrategy,
+  a as PrefixExceptDefaultPathStrategy,
+  u 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
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +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 { RouteLike, ResolvedRouteLike } 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 { PrefixExceptDefaultPathStrategy } from './prefix-except-default'\nimport { PrefixAndDefaultPathStrategy } from './prefix-and-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;"}

package/dist/no-prefix-strategy.cjs

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

package/dist/no-prefix-strategy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-prefix-strategy.cjs","sources":["../src/strategies/no-prefix.ts"],"sourcesContent":["import type { ResolvedRouteLike, RouteLike } from '../core/types'\nimport { BasePathStrategy } from './base-strategy'\nimport { cleanDoubleSlashes } from 'ufo'\nimport { normalizePath } from '../utils/path'\n\nexport class NoPrefixPathStrategy extends BasePathStrategy {\n  protected buildLocalizedPath(path: string, _locale: string, _isCustom: boolean): string {\n    return normalizePath(path)\n  }\n\n  protected buildLocalizedRouteName(baseName: string, locale: string): string {\n    return this.buildLocalizedName(baseName, locale)\n  }\n\n  override getCanonicalPath(route: ResolvedRouteLike, targetLocale: string): string | null {\n    const segment = this.getCustomPathSegment(route, targetLocale)\n    if (!segment) return null\n    return segment.startsWith('/') ? segment : `/${segment}`\n  }\n\n  resolveLocaleFromPath(_path: string): string | null {\n    return null\n  }\n\n  override getLocaleFromPath(path: string): string | null {\n    return super.getLocaleFromPath(path)\n  }\n\n  /** NoPrefix: when router does not know the route — return source route unchanged. */\n  protected override getSwitchLocaleFallbackWhenNoRoute(route: ResolvedRouteLike, _targetName: string): RouteLike | string {\n    return route\n  }\n\n  /**\n   * In no_prefix strategy, URL should not contain locale. If path starts with a locale segment,\n   * redirect to path without it. Controlled by ctx.noPrefixRedirect (default: true).\n   */\n  getRedirect(currentPath: string, _targetLocale: string): string | null {\n    if (this.ctx.noPrefixRedirect === false) return null\n    const pathLocale = this.getLocaleFromPath(currentPath)\n    if (!pathLocale) return null\n    const prefix = `/${pathLocale}`\n    let newPath = currentPath.slice(prefix.length)\n    if (!newPath || !newPath.startsWith('/')) newPath = '/' + (newPath || '')\n    return cleanDoubleSlashes(newPath) || '/'\n  }\n}\n\n/** Alias for Nuxt alias consumption. */\nexport { NoPrefixPathStrategy as Strategy }\n"],"names":["NoPrefixPathStrategy","BasePathStrategy","path","_locale","_isCustom","normalizePath","baseName","locale","route","targetLocale","segment","_path","_targetName","currentPath","_targetLocale","pathLocale","prefix","newPath","cleanDoubleSlashes"],"mappings":"gIAKO,MAAMA,UAA6BC,EAAAA,gBAAiB,CAC/C,mBAAmBC,EAAcC,EAAiBC,EAA4B,CACtF,OAAOC,EAAAA,cAAcH,CAAI,CAC3B,CAEU,wBAAwBI,EAAkBC,EAAwB,CAC1E,OAAO,KAAK,mBAAmBD,EAAUC,CAAM,CACjD,CAES,iBAAiBC,EAA0BC,EAAqC,CACvF,MAAMC,EAAU,KAAK,qBAAqBF,EAAOC,CAAY,EAC7D,OAAKC,EACEA,EAAQ,WAAW,GAAG,EAAIA,EAAU,IAAIA,CAAO,GADjC,IAEvB,CAEA,sBAAsBC,EAA8B,CAClD,OAAO,IACT,CAES,kBAAkBT,EAA6B,CACtD,OAAO,MAAM,kBAAkBA,CAAI,CACrC,CAGmB,mCAAmCM,EAA0BI,EAAyC,CACvH,OAAOJ,CACT,CAMA,YAAYK,EAAqBC,EAAsC,CACrE,GAAI,KAAK,IAAI,mBAAqB,GAAO,OAAO,KAChD,MAAMC,EAAa,KAAK,kBAAkBF,CAAW,EACrD,GAAI,CAACE,EAAY,OAAO,KACxB,MAAMC,EAAS,IAAID,CAAU,GAC7B,IAAIE,EAAUJ,EAAY,MAAMG,EAAO,MAAM,EAC7C,OAAI,CAACC,GAAW,CAACA,EAAQ,WAAW,GAAG,KAAGA,EAAU,KAAOA,GAAW,KAC/DC,EAAAA,mBAAmBD,CAAO,GAAK,GACxC,CACF"}

package/dist/no-prefix-strategy.d.ts

@@ -0,0 +1,283 @@
+import { I18nRouteParams } from '@i18n-micro/types';
+import { Locale } from '@i18n-micro/types';
+import { Strategies } from '@i18n-micro/types';
+
+declare abstract class BasePathStrategy implements PathStrategy {
+    protected ctx: PathStrategyContext;
+    protected resolver: RouteResolver;
+    constructor(ctx: PathStrategyContext);
+    setRouter(router: RouterAdapter): void;
+    getDefaultLocale(): string;
+    getLocales(): Locale[];
+    getStrategy(): PathStrategyContext['strategy'];
+    getLocalizedRouteNamePrefix(): string;
+    getGlobalLocaleRoutes(): PathStrategyContext['globalLocaleRoutes'];
+    getRouteLocales(): PathStrategyContext['routeLocales'];
+    getRoutesLocaleLinks(): PathStrategyContext['routesLocaleLinks'];
+    getNoPrefixRedirect(): boolean | undefined;
+    /** Strips localization prefix/suffix and returns the "base" route name for one locale. */
+    protected getBaseRouteName(route: RouteLike, locale: string): string | null;
+    /** Returns the base route name (without localized prefix/suffix) by trying all locales. */
+    getRouteBaseName(route: RouteLike): 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): {
+        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;
+    /**
+     * 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).
+     */
+    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;
+}
+
+/** Custom path rules: route key -> locale -> path segment. false = unlocalized route. */
+declare type GlobalLocaleRoutes = Record<string, Record<string, string> | false>;
+
+declare interface HreflangTag {
+    rel: 'alternate';
+    href: string;
+    hreflang: string;
+}
+
+declare class NoPrefixPathStrategy 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;
+    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).
+     */
+    getRedirect(currentPath: string, _targetLocale: string): string | null;
+}
+export { NoPrefixPathStrategy }
+export { NoPrefixPathStrategy as Strategy }
+
+/** Normalized input for resolveLocaleRoute (template method). */
+declare type NormalizedRouteInput = {
+    kind: 'path';
+    path: string;
+} | {
+    kind: 'route';
+    inputName: string | null;
+    sourceRoute: RouteLike;
+    resolved: ResolvedRouteLike;
+};
+
+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;
+    /**
+     * 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;
+    getDefaultLocale(): string;
+    getLocales(): Locale[];
+    getStrategy(): Strategies;
+    getLocalizedRouteNamePrefix(): string;
+    getGlobalLocaleRoutes(): GlobalLocaleRoutes | undefined;
+    getRouteLocales(): Record<string, string[]> | undefined;
+    getRoutesLocaleLinks(): Record<string, string> | undefined;
+    getNoPrefixRedirect(): boolean | undefined;
+}
+
+declare interface PathStrategyContext {
+    strategy: Strategies;
+    defaultLocale: string;
+    locales: Locale[];
+    localizedRouteNamePrefix: string;
+    globalLocaleRoutes?: GlobalLocaleRoutes;
+    routeLocales?: Record<string, string[]>;
+    routesLocaleLinks?: Record<string, string>;
+    includeDefaultLocaleRoute?: boolean;
+    noPrefixRedirect?: boolean;
+    debug?: boolean;
+    router: RouterAdapter;
+}
+
+/** Resolved route (path and fullPath required). */
+declare interface ResolvedRouteLike extends RouteLike {
+    name: string | null;
+    path: string;
+    fullPath: string;
+}
+
+/** Route-like shape (compatible with vue-router). */
+declare interface RouteLike {
+    name?: string | null;
+    path?: string;
+    params?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    hash?: string;
+    fullPath?: string;
+}
+
+declare interface RouterAdapter {
+    hasRoute: (name: string) => boolean;
+    resolve: (to: RouteLike | string) => ResolvedRouteLike;
+    getRoutes?: () => unknown[];
+}
+
+declare class RouteResolver {
+    private ctx;
+    constructor(ctx: PathStrategyContext);
+    /**
+     * Substitutes params into path template (:key, :key(), [...key]).
+     * Uses one combined regex per key to avoid creating multiple RegExp in a loop.
+     */
+    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;
+}
+
+export { }

package/dist/no-prefix-strategy.mjs

@@ -0,0 +1,40 @@
+import { B as o, n as s, c as n } from "./base-strategy-DVqe8ehd.js";
+class h extends o {
+  buildLocalizedPath(t, a, e) {
+    return s(t);
+  }
+  buildLocalizedRouteName(t, a) {
+    return this.buildLocalizedName(t, a);
+  }
+  getCanonicalPath(t, a) {
+    const e = this.getCustomPathSegment(t, a);
+    return e ? e.startsWith("/") ? e : `/${e}` : null;
+  }
+  resolveLocaleFromPath(t) {
+    return null;
+  }
+  getLocaleFromPath(t) {
+    return super.getLocaleFromPath(t);
+  }
+  /** NoPrefix: when router does not know the route — return source route unchanged. */
+  getSwitchLocaleFallbackWhenNoRoute(t, a) {
+    return t;
+  }
+  /**
+   * 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).
+   */
+  getRedirect(t, a) {
+    if (this.ctx.noPrefixRedirect === !1) return null;
+    const e = this.getLocaleFromPath(t);
+    if (!e) return null;
+    const l = `/${e}`;
+    let r = t.slice(l.length);
+    return (!r || !r.startsWith("/")) && (r = "/" + (r || "")), n(r) || "/";
+  }
+}
+export {
+  h as NoPrefixPathStrategy,
+  h as Strategy
+};
+//# sourceMappingURL=no-prefix-strategy.mjs.map

package/dist/no-prefix-strategy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-prefix-strategy.mjs","sources":["../src/strategies/no-prefix.ts"],"sourcesContent":["import type { ResolvedRouteLike, RouteLike } from '../core/types'\nimport { BasePathStrategy } from './base-strategy'\nimport { cleanDoubleSlashes } from 'ufo'\nimport { normalizePath } from '../utils/path'\n\nexport class NoPrefixPathStrategy extends BasePathStrategy {\n  protected buildLocalizedPath(path: string, _locale: string, _isCustom: boolean): string {\n    return normalizePath(path)\n  }\n\n  protected buildLocalizedRouteName(baseName: string, locale: string): string {\n    return this.buildLocalizedName(baseName, locale)\n  }\n\n  override getCanonicalPath(route: ResolvedRouteLike, targetLocale: string): string | null {\n    const segment = this.getCustomPathSegment(route, targetLocale)\n    if (!segment) return null\n    return segment.startsWith('/') ? segment : `/${segment}`\n  }\n\n  resolveLocaleFromPath(_path: string): string | null {\n    return null\n  }\n\n  override getLocaleFromPath(path: string): string | null {\n    return super.getLocaleFromPath(path)\n  }\n\n  /** NoPrefix: when router does not know the route — return source route unchanged. */\n  protected override getSwitchLocaleFallbackWhenNoRoute(route: ResolvedRouteLike, _targetName: string): RouteLike | string {\n    return route\n  }\n\n  /**\n   * In no_prefix strategy, URL should not contain locale. If path starts with a locale segment,\n   * redirect to path without it. Controlled by ctx.noPrefixRedirect (default: true).\n   */\n  getRedirect(currentPath: string, _targetLocale: string): string | null {\n    if (this.ctx.noPrefixRedirect === false) return null\n    const pathLocale = this.getLocaleFromPath(currentPath)\n    if (!pathLocale) return null\n    const prefix = `/${pathLocale}`\n    let newPath = currentPath.slice(prefix.length)\n    if (!newPath || !newPath.startsWith('/')) newPath = '/' + (newPath || '')\n    return cleanDoubleSlashes(newPath) || '/'\n  }\n}\n\n/** Alias for Nuxt alias consumption. */\nexport { NoPrefixPathStrategy as Strategy }\n"],"names":["NoPrefixPathStrategy","BasePathStrategy","path","_locale","_isCustom","normalizePath","baseName","locale","route","targetLocale","segment","_path","_targetName","currentPath","_targetLocale","pathLocale","prefix","newPath","cleanDoubleSlashes"],"mappings":";AAKO,MAAMA,UAA6BC,EAAiB;AAAA,EAC/C,mBAAmBC,GAAcC,GAAiBC,GAA4B;AACtF,WAAOC,EAAcH,CAAI;AAAA,EAC3B;AAAA,EAEU,wBAAwBI,GAAkBC,GAAwB;AAC1E,WAAO,KAAK,mBAAmBD,GAAUC,CAAM;AAAA,EACjD;AAAA,EAES,iBAAiBC,GAA0BC,GAAqC;AACvF,UAAMC,IAAU,KAAK,qBAAqBF,GAAOC,CAAY;AAC7D,WAAKC,IACEA,EAAQ,WAAW,GAAG,IAAIA,IAAU,IAAIA,CAAO,KADjC;AAAA,EAEvB;AAAA,EAEA,sBAAsBC,GAA8B;AAClD,WAAO;AAAA,EACT;AAAA,EAES,kBAAkBT,GAA6B;AACtD,WAAO,MAAM,kBAAkBA,CAAI;AAAA,EACrC;AAAA;AAAA,EAGmB,mCAAmCM,GAA0BI,GAAyC;AACvH,WAAOJ;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,YAAYK,GAAqBC,GAAsC;AACrE,QAAI,KAAK,IAAI,qBAAqB,GAAO,QAAO;AAChD,UAAMC,IAAa,KAAK,kBAAkBF,CAAW;AACrD,QAAI,CAACE,EAAY,QAAO;AACxB,UAAMC,IAAS,IAAID,CAAU;AAC7B,QAAIE,IAAUJ,EAAY,MAAMG,EAAO,MAAM;AAC7C,YAAI,CAACC,KAAW,CAACA,EAAQ,WAAW,GAAG,OAAGA,IAAU,OAAOA,KAAW,MAC/DC,EAAmBD,CAAO,KAAK;AAAA,EACxC;AACF;"}

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

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./base-strategy-B5mBf3XX.cjs");class B extends e.BasePathStrategy{buildLocalizedPath(t,h,s){return e.joinUrl(h,e.normalizePath(t))}buildLocalizedRouteName(t,h){return this.buildLocalizedName(t,h)}switchLocaleRoute(t,h,s,l){const o=this.getBaseRouteName(s,t);if(!o)return s;const i=this.buildLocalizedName(o,h);if(this.ctx.router.hasRoute(i)){const c=l.i18nRouteParams?.[h]||{},r={...s.params||{},...c};return delete r.locale,this.applyBaseUrl(h,{name:i,params:r,query:s.query,hash:s.hash})}return{...s,name:i}}resolveLocaleRoute(t,h,s){if(h.kind==="path"){const a=this.resolvePathForLocale(h.path,t),n=`/${t}`;return this.applyBaseUrl(t,e.joinUrl(n,e.withLeadingSlash(a)))}const{inputName:l,sourceRoute:o,resolved:i}=h;if(l){const a=this.getPathForUnlocalizedRouteByName(l);if(a!==null)return a}const c=o.params&&Object.keys(o.params??{}).length>0;if(l&&c){const a=this.tryResolveByLocalizedNameWithParams(l,t,o.params??{},o);if(a!==null){const n=a.path??"",{pathWithoutLocale:u}=this.getPathWithoutLocale(n),m=u==="/"||u===""?`/${t}`:e.joinUrl(`/${t}`,e.withLeadingSlash(u)),d=e.buildUrl(m,a.query,a.hash),y={...a,path:m,fullPath:d};return this.applyBaseUrl(t,y)}}const r=this.getPathForUnlocalizedRoute(i);if(r!==null)return this.applyBaseUrl(t,r);const W=this.getCustomPathSegment(i,t);if(W!==null){const a=`/${t}`;return this.applyBaseUrl(t,e.joinUrl(a,e.withLeadingSlash(W)))}const p=this.getRouteBaseName(i)??l??i.name?.toString()??null;if(l&&!c){let a=this.tryResolveByLocalizedName(l,t,o);const n=this.getLocalizedRouteNamePrefix();if(a===null&&p!=null&&p!==l&&l.startsWith(n)&&(a=this.tryResolveByLocalizedName(p,t,o)),a!==null){const u=a.path??"",{pathWithoutLocale:m}=this.getPathWithoutLocale(u),d=m==="/"||m===""?`/${t}`:e.joinUrl(`/${t}`,e.withLeadingSlash(m)),y=e.buildUrl(d,a.query,a.hash),R={...a,path:d,fullPath:y};return this.applyBaseUrl(t,R)}}if(i.path&&i.path!=="/"&&i.name){const{pathWithoutLocale:a}=this.getPathWithoutLocaleAndBaseName(i);if(a&&a!=="/")return this.applyBaseUrl(t,e.joinUrl(`/${t}`,e.withLeadingSlash(a)))}const N=s?this.detectLocaleFromName(s.name):this.detectLocaleFromName(i.name),P=N?this.getBaseRouteName(i,N):p;if(!P){const{pathWithoutLocale:a}=this.getPathWithoutLocale(i.path??"/"),n=a==="/"||a===""?`/${t}`:e.joinUrl(`/${t}`,e.withLeadingSlash(a)),u=e.buildUrl(n,o.query,o.hash);return this.applyBaseUrl(t,{...o,path:n,fullPath:u})}const S=this.buildLocalizedName(P,t),g=e.isIndexRouteName(P)?"/":e.joinUrl("/",e.transformNameKeyToPath(P)),U=e.joinUrl(`/${t}`,e.withLeadingSlash(g)),f=this.applyBaseUrl(t,U),L=typeof f=="string"?f:f.path??U,b={name:S,path:L,fullPath:L,params:{...i.params,...o.params},query:{...i.query,...o.query},hash:o.hash??i.hash};return this.applyBaseUrl(t,b)}getCanonicalPath(t,h){const s=this.getCustomPathSegment(t,h);return s?e.joinUrl(`/${h}`,e.withLeadingSlash(s)):null}detectLocaleFromName(t){if(!t)return null;for(const h of this.ctx.locales)if(t.endsWith(`-${h.code}`))return h.code;return null}resolveLocaleFromPath(t){const{localeFromPath:h}=this.getPathWithoutLocale(t);return h}getRedirect(t,h){const{pathWithoutLocale:s,localeFromPath:l}=this.getPathWithoutLocale(t),o=this.ctx.globalLocaleRoutes;if(o&&l!==null){const r=s==="/"?"/":e.withoutLeadingSlash(s);if(o[s]===!1||o[r]===!1)return e.normalizePathForCompare(s==="/"?"/":s)}const i=this.buildPathWithPrefix(s,h),c=e.getCleanPath(t);return l===h&&e.isSamePath(c,i)?null:i}buildPathWithPrefix(t,h){const s=this.resolvePathForLocale(t,h);return s==="/"||s===""?`/${h}`:e.joinUrl(`/${h}`,s)}}exports.PrefixAndDefaultPathStrategy=B;exports.Strategy=B;
+//# sourceMappingURL=prefix-and-default-strategy.cjs.map

package/dist/prefix-and-default-strategy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefix-and-default-strategy.cjs","sources":["../src/strategies/prefix-and-default.ts"],"sourcesContent":["import type { NormalizedRouteInput, ResolvedRouteLike, RouteLike, SwitchLocaleOptions } from '../core/types'\nimport { BasePathStrategy } from './base-strategy'\nimport { isSamePath, withLeadingSlash, withoutLeadingSlash } from 'ufo'\nimport { buildUrl, getCleanPath, joinUrl, normalizePath, normalizePathForCompare, transformNameKeyToPath } from '../utils/path'\nimport { isIndexRouteName } from '../utils/route-name'\n\n/**\n * prefix_and_default: default locale has both /path and /en/path.\n * We use prefixed route names for consistency (localized-name-en).\n */\nexport class PrefixAndDefaultPathStrategy extends BasePathStrategy {\n  protected buildLocalizedPath(path: string, locale: string, _isCustom: boolean): string {\n    return joinUrl(locale, normalizePath(path))\n  }\n\n  protected buildLocalizedRouteName(baseName: string, locale: string): string {\n    return this.buildLocalizedName(baseName, locale)\n  }\n\n  override switchLocaleRoute(\n    fromLocale: string,\n    toLocale: string,\n    route: ResolvedRouteLike,\n    options: SwitchLocaleOptions,\n  ): RouteLike | string {\n    const baseName = this.getBaseRouteName(route, fromLocale)\n    if (!baseName) return route\n\n    const targetName = this.buildLocalizedName(baseName, toLocale)\n\n    if (this.ctx.router.hasRoute(targetName)) {\n      const i18nParams = options.i18nRouteParams?.[toLocale] || {}\n      const newParams = { ...(route.params || {}), ...i18nParams }\n      delete (newParams as Record<string, unknown>).locale\n\n      return this.applyBaseUrl(toLocale, {\n        name: targetName,\n        params: newParams,\n        query: route.query,\n        hash: route.hash,\n      }) as RouteLike\n    }\n\n    return { ...route, name: targetName }\n  }\n\n  protected override resolveLocaleRoute(\n    targetLocale: string,\n    normalized: NormalizedRouteInput,\n    currentRoute?: ResolvedRouteLike,\n  ): RouteLike | string {\n    if (normalized.kind === 'path') {\n      const resolvedPath = this.resolvePathForLocale(normalized.path, targetLocale)\n      const prefix = `/${targetLocale}`\n      return this.applyBaseUrl(targetLocale, joinUrl(prefix, withLeadingSlash(resolvedPath)))\n    }\n\n    const { inputName, sourceRoute, resolved } = normalized\n    if (inputName) {\n      const unlocalizedByName = this.getPathForUnlocalizedRouteByName(inputName)\n      if (unlocalizedByName !== null) return unlocalizedByName\n    }\n    const hasParams = sourceRoute.params && Object.keys(sourceRoute.params ?? {}).length > 0\n    if (inputName && hasParams) {\n      const routeWithParams = this.tryResolveByLocalizedNameWithParams(\n        inputName,\n        targetLocale,\n        sourceRoute.params ?? {},\n        sourceRoute,\n      )\n      if (routeWithParams !== null) {\n        const resolvedPath = routeWithParams.path ?? ''\n        const { pathWithoutLocale } = this.getPathWithoutLocale(resolvedPath)\n        const pathWithLocale = pathWithoutLocale === '/' || pathWithoutLocale === ''\n          ? `/${targetLocale}`\n          : joinUrl(`/${targetLocale}`, withLeadingSlash(pathWithoutLocale))\n        const fullPathWithLocale = buildUrl(pathWithLocale, routeWithParams.query, routeWithParams.hash)\n        const routeWithPath: RouteLike = {\n          ...routeWithParams,\n          path: pathWithLocale,\n          fullPath: fullPathWithLocale,\n        }\n        return this.applyBaseUrl(targetLocale, routeWithPath)\n      }\n    }\n\n    const unlocalizedPath = this.getPathForUnlocalizedRoute(resolved)\n    if (unlocalizedPath !== null) return this.applyBaseUrl(targetLocale, unlocalizedPath)\n\n    const customSegment = this.getCustomPathSegment(resolved, targetLocale)\n    if (customSegment !== null) {\n      const prefix = `/${targetLocale}`\n      return this.applyBaseUrl(targetLocale, joinUrl(prefix, withLeadingSlash(customSegment)))\n    }\n    const baseName = this.getRouteBaseName(resolved) ?? inputName ?? resolved.name?.toString() ?? null\n    if (inputName && !hasParams) {\n      let routeByLocalizedName = this.tryResolveByLocalizedName(inputName, targetLocale, sourceRoute)\n      const prefix = this.getLocalizedRouteNamePrefix()\n      if (routeByLocalizedName === null && baseName != null && baseName !== inputName && inputName.startsWith(prefix)) {\n        routeByLocalizedName = this.tryResolveByLocalizedName(baseName, targetLocale, sourceRoute)\n      }\n      if (routeByLocalizedName !== null) {\n        // Router may return path without locale prefix (e.g. Nuxt file-based /contact). For prefix_and_default\n        // we always need path with locale (e.g. /en/contact).\n        const resolvedPath = routeByLocalizedName.path ?? ''\n        const { pathWithoutLocale } = this.getPathWithoutLocale(resolvedPath)\n        const pathWithLocale = pathWithoutLocale === '/' || pathWithoutLocale === ''\n          ? `/${targetLocale}`\n          : joinUrl(`/${targetLocale}`, withLeadingSlash(pathWithoutLocale))\n        const fullPathWithLocale = buildUrl(pathWithLocale, routeByLocalizedName.query, routeByLocalizedName.hash)\n        const routeWithPath: RouteLike = {\n          ...routeByLocalizedName,\n          path: pathWithLocale,\n          fullPath: fullPathWithLocale,\n        }\n        return this.applyBaseUrl(targetLocale, routeWithPath)\n      }\n    }\n    if (resolved.path && resolved.path !== '/' && resolved.name) {\n      const { pathWithoutLocale } = this.getPathWithoutLocaleAndBaseName(resolved)\n      if (pathWithoutLocale && pathWithoutLocale !== '/') {\n        return this.applyBaseUrl(targetLocale, joinUrl(`/${targetLocale}`, withLeadingSlash(pathWithoutLocale)))\n      }\n    }\n\n    const fromLocale = currentRoute\n      ? this.detectLocaleFromName(currentRoute.name)\n      : this.detectLocaleFromName(resolved.name)\n\n    const fallbackBaseName = fromLocale\n      ? this.getBaseRouteName(resolved, fromLocale)\n      : baseName\n\n    if (!fallbackBaseName) {\n      // Never return unprefixed path for prefix_and_default. Build path from resolved.\n      const { pathWithoutLocale } = this.getPathWithoutLocale(resolved.path ?? '/')\n      const pathWithLocale = pathWithoutLocale === '/' || pathWithoutLocale === ''\n        ? `/${targetLocale}`\n        : joinUrl(`/${targetLocale}`, withLeadingSlash(pathWithoutLocale))\n      const fullPathWithLocale = buildUrl(pathWithLocale, sourceRoute.query, sourceRoute.hash)\n      return this.applyBaseUrl(targetLocale, {\n        ...sourceRoute,\n        path: pathWithLocale,\n        fullPath: fullPathWithLocale,\n      })\n    }\n\n    const targetName = this.buildLocalizedName(fallbackBaseName, targetLocale)\n\n    const pathWithoutLocale = isIndexRouteName(fallbackBaseName)\n      ? '/'\n      : joinUrl('/', transformNameKeyToPath(fallbackBaseName))\n    const pathForLocale = joinUrl(`/${targetLocale}`, withLeadingSlash(pathWithoutLocale))\n    const withBase = this.applyBaseUrl(targetLocale, pathForLocale)\n    const pathStr = typeof withBase === 'string' ? withBase : (withBase as RouteLike).path ?? pathForLocale\n\n    const newRoute: RouteLike = {\n      name: targetName,\n      path: pathStr,\n      fullPath: pathStr,\n      params: { ...resolved.params, ...sourceRoute.params },\n      query: { ...resolved.query, ...sourceRoute.query },\n      hash: sourceRoute.hash ?? resolved.hash,\n    }\n    return this.applyBaseUrl(targetLocale, newRoute)\n  }\n\n  override getCanonicalPath(route: ResolvedRouteLike, targetLocale: string): string | null {\n    const segment = this.getCustomPathSegment(route, targetLocale)\n    if (!segment) return null\n    return joinUrl(`/${targetLocale}`, withLeadingSlash(segment))\n  }\n\n  protected detectLocaleFromName(name: string | null): string | null {\n    if (!name) return null\n    for (const locale of this.ctx.locales) {\n      if (name.endsWith(`-${locale.code}`)) {\n        return locale.code\n      }\n    }\n    return null\n  }\n\n  resolveLocaleFromPath(path: string): string | null {\n    const { localeFromPath } = this.getPathWithoutLocale(path)\n    return localeFromPath\n  }\n\n  getRedirect(currentPath: string, detectedLocale: string): string | null {\n    const { pathWithoutLocale, localeFromPath } = this.getPathWithoutLocale(currentPath)\n    // Unlocalized routes (globalLocaleRoutes[key] === false): redirect /locale/path to /path\n    const gr = this.ctx.globalLocaleRoutes\n    if (gr && localeFromPath !== null) {\n      const pathKey = pathWithoutLocale === '/' ? '/' : withoutLeadingSlash(pathWithoutLocale)\n      if (gr[pathWithoutLocale] === false || gr[pathKey] === false) {\n        return normalizePathForCompare(pathWithoutLocale === '/' ? '/' : pathWithoutLocale)\n      }\n    }\n    const expectedPath = this.buildPathWithPrefix(pathWithoutLocale, detectedLocale)\n    const currentPathOnly = getCleanPath(currentPath)\n    if (localeFromPath === detectedLocale && isSamePath(currentPathOnly, expectedPath)) {\n      return null\n    }\n    return expectedPath\n  }\n\n  private buildPathWithPrefix(pathWithoutLocale: string, locale: string): string {\n    const resolved = this.resolvePathForLocale(pathWithoutLocale, locale)\n    if (resolved === '/' || resolved === '') {\n      return `/${locale}`\n    }\n    return joinUrl(`/${locale}`, resolved)\n  }\n}\n\n/** Alias for Nuxt alias consumption. */\nexport { PrefixAndDefaultPathStrategy as Strategy }\n"],"names":["PrefixAndDefaultPathStrategy","BasePathStrategy","path","locale","_isCustom","joinUrl","normalizePath","baseName","fromLocale","toLocale","route","options","targetName","i18nParams","newParams","targetLocale","normalized","currentRoute","resolvedPath","prefix","withLeadingSlash","inputName","sourceRoute","resolved","unlocalizedByName","hasParams","routeWithParams","pathWithoutLocale","pathWithLocale","fullPathWithLocale","buildUrl","routeWithPath","unlocalizedPath","customSegment","routeByLocalizedName","fallbackBaseName","isIndexRouteName","transformNameKeyToPath","pathForLocale","withBase","pathStr","newRoute","segment","name","localeFromPath","currentPath","detectedLocale","gr","pathKey","withoutLeadingSlash","normalizePathForCompare","expectedPath","currentPathOnly","getCleanPath","isSamePath"],"mappings":"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"}