@i18n-micro/path-strategy 1.0.3 → 1.1.2

package/dist/base-strategy-Cf39XK8k.js

@@ -0,0 +1,926 @@
+const nt = /#/g, lt = /&/g, it = /\//g, ct = /=/g, w = /\+/g, H = /%5e/gi, ht = /%60/gi, ut = /%7b/gi, ft = /%7c/gi, dt = /%7d/gi, pt = /%20/gi;
+function G(o) {
+  return encodeURI("" + o).replace(ft, "|");
+}
+function mt(o) {
+  return G(o).replace(ut, "{").replace(dt, "}").replace(H, "^");
+}
+function C(o) {
+  return G(typeof o == "string" ? o : JSON.stringify(o)).replace(w, "%2B").replace(pt, "+").replace(nt, "%23").replace(lt, "%26").replace(ht, "`").replace(H, "^").replace(it, "%2F");
+}
+function k(o) {
+  return C(o).replace(ct, "%3D");
+}
+function A(o = "") {
+  try {
+    return decodeURIComponent("" + o);
+  } catch {
+    return "" + o;
+  }
+}
+function gt(o) {
+  return A(o.replace(w, " "));
+}
+function yt(o) {
+  return A(o.replace(w, " "));
+}
+function Pt(o = "") {
+  const t = /* @__PURE__ */ Object.create(null);
+  o[0] === "?" && (o = o.slice(1));
+  for (const e of o.split("&")) {
+    const s = e.match(/([^=]+)=?(.*)/) || [];
+    if (s.length < 2)
+      continue;
+    const a = gt(s[1]);
+    if (a === "__proto__" || a === "constructor")
+      continue;
+    const r = yt(s[2] || "");
+    t[a] === void 0 ? t[a] = r : Array.isArray(t[a]) ? t[a].push(r) : t[a] = [t[a], r];
+  }
+  return t;
+}
+function Rt(o, t) {
+  return (typeof t == "number" || typeof t == "boolean") && (t = String(t)), t ? Array.isArray(t) ? t.map(
+    (e) => `${k(o)}=${C(e)}`
+  ).join("&") : `${k(o)}=${C(t)}` : k(o);
+}
+function Lt(o) {
+  return Object.keys(o).filter((t) => o[t] !== void 0).map((t) => Rt(t, o[t])).filter(Boolean).join("&");
+}
+const xt = /^[\s\w\0+.-]{2,}:([/\\]{1,2})/, bt = /^[\s\w\0+.-]{2,}:([/\\]{2})?/, Nt = /^([/\\]\s*){2,}[^/\\]/, vt = /^\.?\//;
+function z(o, t = {}) {
+  return typeof t == "boolean" && (t = { acceptRelative: t }), t.strict ? xt.test(o) : bt.test(o) || (t.acceptRelative ? Nt.test(o) : !1);
+}
+function zt(o = "", t) {
+  return o.endsWith("/");
+}
+function S(o = "", t) {
+  return (zt(o) ? o.slice(0, -1) : o) || "/";
+}
+function St(o = "", t) {
+  return o.endsWith("/") ? o : o + "/";
+}
+function E(o = "") {
+  return o.startsWith("/");
+}
+function Q(o = "") {
+  return (E(o) ? o.slice(1) : o) || "/";
+}
+function K(o = "") {
+  return E(o) ? o : "/" + o;
+}
+function M(o = "") {
+  return o.split("://").map((t) => t.replace(/\/{2,}/g, "/")).join("://");
+}
+function Bt(o, t) {
+  const e = j(o), s = { ...Pt(e.search), ...t };
+  return e.search = Lt(s), X(e);
+}
+function Wt(o) {
+  return !o || o === "/";
+}
+function Ft(o) {
+  return o && o !== "/";
+}
+function $(o, ...t) {
+  let e = o || "";
+  for (const s of t.filter((a) => Ft(a)))
+    if (e) {
+      const a = s.replace(vt, "");
+      e = St(e) + a;
+    } else
+      e = s;
+  return e;
+}
+function $t(o, t) {
+  return A(S(o)) === A(S(t));
+}
+function At(o, t) {
+  if (!t || t === "#")
+    return o;
+  const e = j(o);
+  return e.hash = t === "" ? "" : "#" + mt(t), X(e);
+}
+const V = /* @__PURE__ */ Symbol.for("ufo:protocolRelative");
+function j(o = "", t) {
+  const e = o.match(
+    /^[\s\0]*(blob:|data:|javascript:|vbscript:)(.*)/i
+  );
+  if (e) {
+    const [, d, g = ""] = e;
+    return {
+      protocol: d.toLowerCase(),
+      pathname: g,
+      href: d + g,
+      auth: "",
+      host: "",
+      search: "",
+      hash: ""
+    };
+  }
+  if (!z(o, { acceptRelative: !0 }))
+    return _(o);
+  const [, s = "", a, r = ""] = o.replace(/\\/g, "/").match(/^[\s\0]*([\w+.-]{2,}:)?\/\/([^/@]+@)?(.*)/) || [];
+  let [, n = "", l = ""] = r.match(/([^#/?]*)(.*)?/) || [];
+  s === "file:" && (l = l.replace(/\/(?=[A-Za-z]:)/, ""));
+  const { pathname: i, search: h, hash: u } = _(l);
+  return {
+    protocol: s.toLowerCase(),
+    auth: a ? a.slice(0, Math.max(0, a.length - 1)) : "",
+    host: n,
+    pathname: i,
+    search: h,
+    hash: u,
+    [V]: !s
+  };
+}
+function _(o = "") {
+  const [t = "", e = "", s = ""] = (o.match(/([^#?]*)(\?[^#]*)?(#.*)?/) || []).splice(1);
+  return {
+    pathname: t,
+    search: e,
+    hash: s
+  };
+}
+function X(o) {
+  const t = o.pathname || "", e = o.search ? (o.search.startsWith("?") ? "" : "?") + o.search : "", s = o.hash || "", a = o.auth ? o.auth + "@" : "", r = o.host || "";
+  return (o.protocol || o[V] ? (o.protocol || "") + "//" : "") + a + r + t + e + s;
+}
+const _t = /\/([^/]+)$/;
+function Et(o = "", t) {
+  const { pathname: e } = j(o), s = e.match(_t);
+  return s ? s[1] : void 0;
+}
+function D(o) {
+  return (_(o.startsWith("/") ? o : `/${o}`).pathname || "").split("/").filter(Boolean);
+}
+const P = (o) => Wt(o ?? "") ? "/" : K(S(M(o))) || "/";
+function jt(o) {
+  const t = M(o || "/");
+  return S(t) || "/";
+}
+function y(...o) {
+  const t = o.filter((r) => typeof r == "string" && r !== "");
+  if (t.length === 0) return "/";
+  const [e, ...s] = t, a = $(e, ...s) || "/";
+  return z(a) ? a : K(a);
+}
+function J(o) {
+  return o && _(o).pathname || "";
+}
+function T(o, t, e) {
+  let s = Bt(o, t ?? {});
+  if (e && e !== "#") {
+    const a = e.startsWith("#") ? e.slice(1) : e;
+    s = At(s, a);
+  }
+  return s;
+}
+function b(o) {
+  if (!o) return "";
+  let t = "";
+  for (let e = 0; e < o.length; e++)
+    t += o[e] === "-" ? "/" : o[e];
+  return t;
+}
+function Y(o) {
+  if (!o) return "";
+  const t = o.indexOf("-");
+  return t === -1 ? o : $(o.slice(0, t), o.slice(t + 1));
+}
+function Z(o) {
+  if (!o) return "";
+  const t = o.lastIndexOf("-");
+  return t === -1 ? o : $(o.slice(0, t), o.slice(t + 1));
+}
+function qt(o) {
+  const t = D(o);
+  return t.length > 1 ? t.slice(0, -1).join("-") : "";
+}
+function Ot(o) {
+  return Et(o || "/") ?? "";
+}
+function tt(o, t) {
+  const e = J(o), s = P(e);
+  if (s === "/")
+    return { pathWithoutLocale: "/", localeFromPath: null };
+  if (!E(s))
+    return { pathWithoutLocale: s, localeFromPath: null };
+  const a = s.indexOf("/", 1), r = a === -1 ? s.slice(1) : s.slice(1, a);
+  if (r && t.includes(r)) {
+    const n = 1 + r.length, l = s.slice(n);
+    return {
+      pathWithoutLocale: P(l || "/"),
+      localeFromPath: r
+    };
+  }
+  return { pathWithoutLocale: s, localeFromPath: null };
+}
+function Ut(o, t) {
+  const e = J(o);
+  if (e === "/" || e === "" || !E(e)) return null;
+  const s = e.indexOf("/", 1), a = s === -1 ? e.slice(1) : e.slice(1, s);
+  return a && t.includes(a) ? a : null;
+}
+function et(o, t) {
+  const e = o.name?.toString();
+  if (!e) return null;
+  const s = t.localizedRouteNamePrefix || "localized-", a = e.startsWith(s) ? e.slice(s.length) : e, r = [...t.locales].sort((n, l) => l.code.length - n.code.length);
+  for (const n of r) {
+    const l = `-${n.code}`;
+    if (!a.endsWith(l)) continue;
+    const i = a.length - n.code.length - 1;
+    if (i >= 0 && a[i] === "-")
+      return a.slice(0, -l.length);
+  }
+  return a;
+}
+function kt(o, t, e = "localized-") {
+  return `${e}${o}-${t}`;
+}
+function I(o, t) {
+  if (o == null) return !1;
+  const e = String(o).trim();
+  if (e === "" || e === "index") return !0;
+  const s = t?.localizedRouteNamePrefix ?? "localized-", a = t?.localeCodes ?? [], r = `${s}index-`;
+  if (!e.startsWith(r)) return !1;
+  const n = e.slice(r.length);
+  return a.length === 0 ? n.length >= 2 : a.includes(n);
+}
+function Ct(o) {
+  return o.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+class wt {
+  constructor(t) {
+    this.ctx = t;
+  }
+  /**
+   * Substitutes params into path template (:key, :key(), [...key]).
+   * Uses one combined regex per key to avoid creating multiple RegExp in a loop.
+   */
+  resolvePathWithParams(t, e = {}) {
+    let s = t;
+    for (const a in e) {
+      const r = e[a];
+      if (r == null || r === "") continue;
+      const n = Array.isArray(r) ? r.join("/") : String(r), l = Ct(a), i = new RegExp(`:${l}\\(\\)|:${l}(?![\\w])|\\[\\.\\.\\.${l}\\]`, "g");
+      s = s.replace(i, n);
+    }
+    return s;
+  }
+  /**
+   * Analyzes route: path without locale and base name (normalizer + route-name).
+   */
+  analyzeRoute(t) {
+    const e = this.ctx.locales.map((r) => r.code), { pathWithoutLocale: s } = tt(t.path || "/", e);
+    let a = null;
+    return t.name && (a = et(t, {
+      locales: this.ctx.locales,
+      localizedRouteNamePrefix: this.ctx.localizedRouteNamePrefix || "localized-"
+    })), { pathWithoutLocale: s, baseRouteName: a };
+  }
+  /** Public access to route analysis (for strategies). */
+  getPathWithoutLocaleAndBaseName(t) {
+    return this.analyzeRoute(t);
+  }
+  /**
+   * Lookup keys for config (same order for resolveCustomPath, getPathForUnlocalizedRoute, getAllowedLocalesForRoute).
+   */
+  getLookupKeys(t, e) {
+    const s = [];
+    s.push(t);
+    const a = Q(t);
+    if (a !== t && s.push(a), (t === "/" || a === "") && s.push(""), e) {
+      s.push(`/${e}`), s.push(e);
+      const r = b(e);
+      r && r !== e && s.push(r);
+      const n = Y(e);
+      n && s.push(n);
+      const l = Z(e);
+      l && s.push(l);
+    }
+    return s;
+  }
+  /**
+   * Resolves custom path for targetLocale from globalLocaleRoutes.
+   */
+  resolveCustomPath(t, e) {
+    const s = this.ctx.globalLocaleRoutes;
+    if (!s || Object.keys(s).length === 0) return null;
+    const { pathWithoutLocale: a, baseRouteName: r } = this.analyzeRoute(t), n = this.getLookupKeys(a, r);
+    for (const l of n) {
+      const i = s[l];
+      if (i && typeof i == "object" && !Array.isArray(i)) {
+        const h = i[e];
+        if (typeof h == "string")
+          return this.resolvePathWithParams(h, t.params ?? {});
+      }
+    }
+    return null;
+  }
+  /**
+   * Unlocalized route (globalLocaleRoutes[key] === false) — returns path without locale.
+   */
+  getPathForUnlocalizedRoute(t) {
+    const e = this.ctx.globalLocaleRoutes;
+    if (!e) return null;
+    const { pathWithoutLocale: s, baseRouteName: a } = this.analyzeRoute(t), r = this.getLookupKeys(s, a);
+    for (const n of r)
+      if (e[n] === !1) {
+        if (a && (n === a || n === `/${a}`)) {
+          const l = b(a);
+          return l ? y("/", l) : `/${a}`;
+        }
+        return s;
+      }
+    return null;
+  }
+  /**
+   * Unlocalized by name (when no route object available).
+   */
+  getPathForUnlocalizedRouteByName(t) {
+    const e = this.ctx.globalLocaleRoutes;
+    if (!e) return null;
+    const s = [t, `/${t}`, Q(t)];
+    for (const a of s)
+      if (e[a] === !1) {
+        const r = b(a.startsWith("/") ? a.slice(1) : a);
+        return r ? y("/", r) : a.startsWith("/") ? a : `/${a}`;
+      }
+    return null;
+  }
+  /**
+   * Allowed locales for route (routeLocales).
+   */
+  getAllowedLocalesForRoute(t) {
+    const e = this.ctx.routeLocales;
+    if (!e || Object.keys(e).length === 0)
+      return this.ctx.locales.map((n) => n.code);
+    const { pathWithoutLocale: s, baseRouteName: a } = this.analyzeRoute(t);
+    let r = this.getLookupKeys(s, a);
+    a && this.ctx.routesLocaleLinks?.[a] && (r = [this.ctx.routesLocaleLinks[a], ...r]);
+    for (const n of r) {
+      const l = e[n];
+      if (Array.isArray(l) && l.length > 0)
+        return l.filter((i) => this.ctx.locales.some((h) => h.code === i));
+    }
+    return this.ctx.locales.map((n) => n.code);
+  }
+  /**
+   * Parent path for nested route (parent key -> targetLocale path).
+   */
+  getParentPathForNested(t, e) {
+    if (t.length <= 1) return "/";
+    const s = t.length > 1 ? t.slice(0, -1).join("-") : "", a = this.ctx.globalLocaleRoutes;
+    if (s && a?.[s] && typeof a[s] == "object") {
+      const r = a[s];
+      if (r[e])
+        return P(r[e]);
+    }
+    return y("/", ...t.slice(0, -1));
+  }
+}
+class Qt {
+  constructor(t) {
+    this.ctx = t, this.resolver = new wt(t);
+  }
+  setRouter(t) {
+    this.ctx.router = t;
+  }
+  getDefaultLocale() {
+    return this.ctx.defaultLocale;
+  }
+  getLocales() {
+    return this.ctx.locales;
+  }
+  getStrategy() {
+    return this.ctx.strategy;
+  }
+  getLocalizedRouteNamePrefix() {
+    return this.ctx.localizedRouteNamePrefix || "localized-";
+  }
+  getGlobalLocaleRoutes() {
+    return this.ctx.globalLocaleRoutes;
+  }
+  getRouteLocales() {
+    return this.ctx.routeLocales;
+  }
+  getRoutesLocaleLinks() {
+    return this.ctx.routesLocaleLinks;
+  }
+  getNoPrefixRedirect() {
+    return this.ctx.noPrefixRedirect;
+  }
+  /**
+   * 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(t, e) {
+    const s = e ? [{ code: e }] : this.ctx.locales;
+    return et(t, {
+      locales: s,
+      localizedRouteNamePrefix: this.getLocalizedRouteNamePrefix()
+    });
+  }
+  /** Alias for internal use - strips localization prefix/suffix for specific locale. */
+  getBaseRouteName(t, e) {
+    return this.getRouteBaseName(t, e);
+  }
+  /** Resolves target path for a locale, checking globalLocaleRoutes first. */
+  resolvePathForLocale(t, e) {
+    const s = {
+      path: t,
+      name: null,
+      fullPath: t,
+      params: {}
+    }, a = this.resolver.resolveCustomPath(s, e);
+    return P(a || t);
+  }
+  buildLocalizedName(t, e) {
+    return kt(t, e, this.getLocalizedRouteNamePrefix());
+  }
+  getLocaleObject(t) {
+    return this.ctx.locales.find((e) => e.code === t);
+  }
+  applyBaseUrl(t, e) {
+    if (typeof e == "string") {
+      if (z(e)) return e;
+    } else if (e.path && z(e.path))
+      return e;
+    const s = this.getLocaleObject(t);
+    if (!s?.baseUrl)
+      return e;
+    const a = S(s.baseUrl);
+    if (typeof e == "string") {
+      const l = P(e.startsWith("/") ? e : `/${e}`);
+      return y(a, l);
+    }
+    const r = P(e.path || ""), n = y(a, r);
+    return z(n) ? n : {
+      ...e,
+      path: n,
+      fullPath: n
+    };
+  }
+  /**
+   * Merges target route (strategy result) with query and hash from source route.
+   * Returns normalized RouteLike object.
+   */
+  preserveQueryAndHash(t, e) {
+    if (!e || !e.query && !e.hash)
+      return t;
+    const s = typeof t == "string" ? { path: t } : { ...t };
+    e.query && (s.query = { ...e.query, ...s.query }), !s.hash && e.hash && (s.hash = e.hash);
+    const a = s.path ?? "";
+    return s.fullPath = T(a, s.query, s.hash), s;
+  }
+  resolvePathWithParams(t, e = {}) {
+    return this.resolver.resolvePathWithParams(t, e);
+  }
+  getPathWithoutLocaleAndBaseName(t) {
+    return this.resolver.getPathWithoutLocaleAndBaseName(t);
+  }
+  /** Look up custom path segment for targetLocale in globalLocaleRoutes. */
+  getCustomPathSegment(t, e) {
+    return this.resolver.resolveCustomPath(t, e);
+  }
+  getAllowedLocalesForRoute(t) {
+    return this.resolver.getAllowedLocalesForRoute(t);
+  }
+  getCanonicalPath(t, e) {
+    return null;
+  }
+  getPathForUnlocalizedRouteByName(t) {
+    return this.resolver.getPathForUnlocalizedRouteByName(t);
+  }
+  /**
+   * Try to resolve route by localized name. Returns RouteLike with query/hash from sourceRoute to preserve them.
+   */
+  tryResolveByLocalizedName(t, e, s) {
+    const a = this.getLocalizedRouteNamePrefix(), r = `${a}${t}-${e}`, n = `${a}${t}`;
+    let l;
+    if (this.ctx.router.hasRoute(r))
+      l = r;
+    else if (this.ctx.router.hasRoute(n))
+      l = n;
+    else
+      return this.debugLog("tryResolveByLocalizedName", {
+        routeName: t,
+        targetLocale: e,
+        tried: [r, n],
+        found: !1
+      }), null;
+    this.debugLog("tryResolveByLocalizedName", { routeName: t, targetLocale: e, localizedName: l, found: !0 });
+    const i = { ...s?.params };
+    l === n && (i.locale = e);
+    let h;
+    try {
+      h = this.ctx.router.resolve({
+        name: l,
+        params: i,
+        query: s?.query,
+        hash: s?.hash
+      });
+    } catch {
+      return this.debugLog("tryResolveByLocalizedName resolve error", { localizedName: l, params: i }), null;
+    }
+    return this.debugLog("tryResolveByLocalizedName resolved", { localizedName: l, path: h?.path, fullPath: h?.fullPath }), h?.path ? {
+      name: l,
+      path: h.path,
+      fullPath: h.fullPath,
+      params: h.params,
+      query: h.query ?? s?.query,
+      hash: h.hash ?? s?.hash
+    } : null;
+  }
+  /**
+   * Try to resolve route by localized name with params. Returns RouteLike to preserve query/hash.
+   */
+  tryResolveByLocalizedNameWithParams(t, e, s, a) {
+    const r = this.getLocalizedRouteNamePrefix(), n = `${r}${t}-${e}`, l = `${r}${t}`;
+    let i;
+    if (this.ctx.router.hasRoute(n))
+      i = n;
+    else if (this.ctx.router.hasRoute(l))
+      i = l;
+    else
+      return this.debugLog("tryResolveByLocalizedNameWithParams", {
+        routeName: t,
+        targetLocale: e,
+        params: s,
+        tried: [n, l],
+        found: !1
+      }), null;
+    this.debugLog("tryResolveByLocalizedNameWithParams", { routeName: t, targetLocale: e, params: s, localizedName: i, found: !0 });
+    const h = { ...s };
+    i === l && (h.locale = e);
+    let u;
+    try {
+      u = this.ctx.router.resolve({
+        name: i,
+        params: h,
+        query: a?.query,
+        hash: a?.hash
+      });
+    } catch {
+      return this.debugLog("tryResolveByLocalizedNameWithParams resolve error", { localizedName: i, resolveParams: h }), null;
+    }
+    return this.debugLog("tryResolveByLocalizedNameWithParams resolved", { path: u?.path, fullPath: u?.fullPath }), !u?.path || u.path === "/" ? null : {
+      name: i,
+      path: u.path,
+      fullPath: u.fullPath,
+      params: u.params,
+      query: u.query ?? a?.query,
+      hash: u.hash ?? a?.hash
+    };
+  }
+  getPathForUnlocalizedRoute(t) {
+    return this.resolver.getPathForUnlocalizedRoute(t);
+  }
+  /**
+   * 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).
+   */
+  buildPathFromBaseNameAndParams(t, e, s) {
+    const a = Object.keys(e).filter((u) => e[u] !== void 0 && e[u] !== null && e[u] !== "");
+    if (a.length === 0) return null;
+    let r;
+    const n = a[0];
+    if (a.length === 1 && n !== void 0 && t.endsWith(`-${n}`))
+      r = y("/", `${t.slice(0, t.length - n.length - 1)}-:${n}`);
+    else {
+      const u = b(t), d = u ? u.split("/").filter(Boolean) : [t], g = Math.min(a.length, d.length), R = d.slice(0, d.length - g).concat(a.slice(0, g).map((B) => `:${B}`));
+      r = y("/", ...R);
+    }
+    const l = this.resolvePathWithParams(r, e), i = this.buildLocalizedPath(l, s, !1), h = this.applyBaseUrl(s, i);
+    return typeof h == "string" ? h : h.path ?? i;
+  }
+  getPathWithoutLocale(t) {
+    return tt(
+      t,
+      this.ctx.locales.map((e) => e.code)
+    );
+  }
+  getLocaleFromPath(t) {
+    return Ut(
+      t,
+      this.ctx.locales.map((e) => e.code)
+    );
+  }
+  /**
+   * 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(t) {
+    const { pathWithoutLocale: e, localeFromPath: s } = this.getPathWithoutLocale(t);
+    if (s === null) return null;
+    const a = e === "/" ? "/" : e.replace(/^\//, ""), r = this.ctx.globalLocaleRoutes;
+    if (r && (r[e] === !1 || r[a] === !1))
+      return "Unlocalized route cannot have locale prefix";
+    const n = this.ctx.routeLocales;
+    if (n && Object.keys(n).length > 0) {
+      const l = n[e] ?? n[a];
+      if (Array.isArray(l) && l.length > 0) {
+        const i = this.ctx.locales.map((u) => u.code), h = l.filter((u) => i.includes(u));
+        if (h.length > 0 && !h.includes(s))
+          return "Locale not allowed for this route";
+      }
+    }
+    return 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(t) {
+    const e = this.resolveLocaleFromPath(t.path) ?? this.ctx.defaultLocale, s = this.getCanonicalPath(t, e) ?? t.path, a = this.buildFullUrl(e, s), r = this.getAllowedLocalesForRoute(t), l = this.ctx.locales.filter((i) => r.includes(i.code)).map((i) => {
+      const h = this.localeRoute(i.code, t, t), d = (h.path ?? h.fullPath ?? "") || "/";
+      return {
+        rel: "alternate",
+        hreflang: i.code,
+        href: this.buildFullUrl(i.code, d)
+      };
+    });
+    return { canonical: a, hreflangs: l };
+  }
+  /**
+   * Builds full URL (path + optional baseUrl for locale).
+   */
+  buildFullUrl(t, e) {
+    const s = this.applyBaseUrl(t, e);
+    return typeof s == "string" ? s : s.path ?? e;
+  }
+  /** When router knows neither targetName nor baseName — what to return (strategy may override). */
+  getSwitchLocaleFallbackWhenNoRoute(t, e) {
+    return { ...t, name: e };
+  }
+  /**
+   * Default: baseName → buildLocalizedRouteName → hasRoute → applyBaseUrl; fallback to baseName.
+   */
+  switchLocaleRoute(t, e, s, a) {
+    const r = this.getBaseRouteName(s, t);
+    if (!r) return s;
+    const n = this.buildLocalizedRouteName(r, e), l = `${this.getLocalizedRouteNamePrefix()}${r}`;
+    let i, h = !1;
+    if (this.ctx.router.hasRoute(n))
+      i = n;
+    else if (this.ctx.router.hasRoute(l))
+      i = l, h = !0;
+    else if (this.ctx.router.hasRoute(r))
+      i = r;
+    else
+      return this.getSwitchLocaleFallbackWhenNoRoute(s, n);
+    const u = a.i18nRouteParams?.[e] || {}, d = { ...s.params || {}, ...u };
+    h ? d.locale = e : delete d.locale;
+    const g = {
+      name: i,
+      params: d,
+      query: s.query,
+      hash: s.hash
+    };
+    return this.applyBaseUrl(e, g);
+  }
+  /**
+   * Template Method: BaseStrategy knows "how" (normalize → delegate to strategy).
+   * Always returns RouteLike with path and fullPath (never a string).
+   */
+  localeRoute(t, e, s) {
+    const a = this.normalizeRouteInput(e, s), r = this.resolveLocaleRoute(t, a, s);
+    this.debugLog("localeRoute raw", {
+      rawPath: typeof r == "string" ? r : r.path,
+      rawFullPath: typeof r == "string" ? r : r.fullPath
+    });
+    const n = this.ensureRouteLike(r, a.kind === "route" ? a.sourceRoute : void 0);
+    return this.debugLog("localeRoute after ensureRouteLike", { path: n.path, fullPath: n.fullPath }), n;
+  }
+  /** Normalizes resolveLocaleRoute result into RouteLike (path and fullPath always set). */
+  ensureRouteLike(t, e) {
+    if (typeof t == "string") {
+      const r = t, n = e?.query || e?.hash ? T(r, e?.query, e?.hash) : r;
+      return {
+        path: r,
+        fullPath: n,
+        ...e?.query && { query: e.query },
+        ...e?.hash && { hash: e.hash }
+      };
+    }
+    let s = t.fullPath ?? t.path ?? "", a = t.path ?? s.split("?")[0]?.split("#")[0] ?? s;
+    if (!a && !s) {
+      const r = t.name?.toString() ?? e?.name?.toString() ?? "";
+      I(r, {
+        localizedRouteNamePrefix: this.getLocalizedRouteNamePrefix(),
+        localeCodes: this.ctx.locales.map((n) => n.code)
+      }) && (a = "/", s = "/");
+    }
+    return { ...t, path: a, fullPath: s };
+  }
+  /**
+   * Normalizes localeRoute input into a single structure (path string or route with resolved).
+   */
+  normalizeRouteInput(t, e) {
+    if (typeof t == "string")
+      return { kind: "path", path: t };
+    const s = t, a = s.name?.toString() ?? null;
+    let r;
+    try {
+      r = this.ctx.router.resolve(t), this.debugLog("normalizeRouteInput router.resolve ok", { inputName: a, resolvedPath: r.path, resolvedName: r.name });
+    } catch {
+      r = {
+        name: a,
+        path: s.path ?? "/",
+        fullPath: s.fullPath ?? s.path ?? "/",
+        params: s.params ?? {},
+        query: s.query ?? {},
+        hash: s.hash ?? ""
+      }, this.debugLog("normalizeRouteInput router.resolve catch fallback", { inputName: a, resolvedPath: r.path });
+    }
+    return { kind: "route", inputName: a, sourceRoute: s, resolved: r };
+  }
+  /** Logging when ctx.debug (for localeRoute debugging). Disabled by default. */
+  debugLog(...t) {
+  }
+  /**
+   * Default resolution: uses buildLocalizedPath and buildLocalizedRouteName.
+   * Strategies with different logic (e.g. prefix-except-default) override this method.
+   */
+  resolveLocaleRoute(t, e, s) {
+    if (e.kind === "path") {
+      const c = this.resolvePathForLocale(e.path, t), f = this.buildLocalizedPath(c, t, !1), p = this.applyBaseUrl(t, f);
+      return this.debugLog("branch=path", { targetLocale: t, path: e.path, finalPath: f, out: typeof p == "string" ? p : p.path }), p;
+    }
+    const { inputName: a, sourceRoute: r, resolved: n } = e, l = r.params && Object.keys(r.params ?? {}).length > 0, i = this.getRouteBaseName(n) ?? a ?? n.name?.toString() ?? null, h = n.name?.toString();
+    if (this.debugLog("input", {
+      targetLocale: t,
+      inputName: a,
+      resolvedPath: n.path,
+      resolvedName: n.name,
+      params: r.params,
+      hasParams: l,
+      baseName: i
+    }), a) {
+      const c = this.getPathForUnlocalizedRouteByName(a);
+      if (c !== null)
+        return this.debugLog("branch=unlocalizedByName", { inputName: a, unlocalizedByName: c }), this.preserveQueryAndHash(c, r);
+    }
+    if (a && l) {
+      const c = this.tryResolveByLocalizedNameWithParams(a, t, r.params ?? {}, r);
+      if (c !== null)
+        return this.debugLog("branch=routeWithParams", { inputName: a, path: c.path, fullPath: c.fullPath }), this.preserveQueryAndHash(this.applyBaseUrl(t, c), r);
+    }
+    if (a && !l) {
+      let c = this.tryResolveByLocalizedName(a, t, r);
+      const f = this.getLocalizedRouteNamePrefix();
+      if (c === null && i != null && i !== a && a.startsWith(f) && (c = this.tryResolveByLocalizedName(i, t, r)), c !== null)
+        return this.debugLog("branch=routeByLocalizedName", { inputName: a, path: c.path, fullPath: c.fullPath }), this.preserveQueryAndHash(this.applyBaseUrl(t, c), r);
+    }
+    const u = this.getPathForUnlocalizedRoute(n);
+    if (u !== null) {
+      const c = this.buildLocalizedPath(u, t, !1);
+      return this.debugLog("branch=unlocalizedPath", { unlocalizedPath: u, path: c }), this.preserveQueryAndHash(this.applyBaseUrl(t, c), r);
+    }
+    const d = this.getCustomPathSegment(n, t);
+    if (d !== null) {
+      const c = n.name?.toString() ?? a ?? "", f = c ? Y(c) : "", p = c ? Z(c) : "", m = this.ctx.globalLocaleRoutes, N = f.includes("/") && m?.[f], x = p.includes("/") && m?.[p], st = N || x, at = x ? p : f;
+      let F;
+      if (st) {
+        const U = D(at), v = U.length > 1 ? U.slice(0, -1).join("-") : "", O = v && m?.[v] && typeof m[v] == "object" && !Array.isArray(m[v]) ? m[v] : null, ot = O?.[t] ? P(O[t]) : y("/", ...U.slice(0, -1)), rt = d.startsWith("/") ? d.slice(1) : d;
+        F = y(ot, rt);
+      } else
+        F = P(d);
+      const q = this.buildLocalizedPath(F, t, !0);
+      return this.debugLog("branch=customSegment", { customSegment: d, pathWithoutLocale: F, finalPath: q }), this.preserveQueryAndHash(this.applyBaseUrl(t, q), r);
+    }
+    const g = i ?? a;
+    if (this.debugLog("before effectiveBaseName check", { baseName: i, inputName: a, effectiveBaseName: g, resolvedName: n.name?.toString() }), !g)
+      return this.debugLog("branch=noBaseName", { return: "src" }), r;
+    if (!l && n.path && n.path !== "/" && n.name) {
+      const { pathWithoutLocale: c, baseRouteName: f } = this.getPathWithoutLocaleAndBaseName(n);
+      if (c && c !== "/") {
+        const p = f && c === f ? y("/", b(f)) : c, m = this.buildLocalizedPath(p, t, !1);
+        return this.debugLog("branch=pathFromResolved", { pathWithoutLocale: c, baseRouteName: f, pathToUse: p, finalPath: m }), this.preserveQueryAndHash(this.applyBaseUrl(t, m), r);
+      }
+    }
+    const R = h === a ? g : a ?? g;
+    this.debugLog("fallback build", { resolvedNameStr: h, inputName: a, baseNameForPath: R, targetLocale: t, hasParams: l });
+    const B = this.buildLocalizedRouteName(R, t), L = {
+      ...r,
+      name: B,
+      params: { ...r.params }
+    };
+    if (l) {
+      let c = null;
+      try {
+        const f = this.ctx.router.resolve({ name: R, params: r.params });
+        if (f?.path) {
+          const p = f.path === "/" ? "/" : (() => {
+            const { pathWithoutLocale: x } = this.getPathWithoutLocale(f.path);
+            return x && x !== "/" ? x : f.path;
+          })(), m = this.buildLocalizedPath(p, t, !1), N = this.applyBaseUrl(t, m);
+          c = typeof N == "string" ? N : N.path ?? m;
+        }
+      } catch {
+        c = this.buildPathFromBaseNameAndParams(R, r.params ?? {}, t);
+      }
+      c && (L.path = c, L.fullPath = c);
+    } else {
+      const c = I(R) ? "/" : y("/", b(R)), f = this.buildLocalizedPath(c, t, !1), p = this.applyBaseUrl(t, f), m = typeof p == "string" ? p : p.path ?? f;
+      this.debugLog("fallback !hasParams", { pathWithoutLocale: c, finalPath: f, pathStr: m }), L.path = m, L.fullPath = m;
+    }
+    L.path && delete L.name;
+    const W = this.preserveQueryAndHash(this.applyBaseUrl(t, L), r);
+    return this.debugLog("branch=fallbackNewRoute return", {
+      baseName: i,
+      targetName: B,
+      hasParams: l,
+      newRoutePath: L.path,
+      outPath: typeof W == "string" ? W : W.path
+    }), W;
+  }
+  /**
+   * Extracts locale from URL path by checking the first path segment.
+   */
+  extractLocaleFromPath(t) {
+    if (!t) return null;
+    const s = t.split("?")[0]?.split("#")[0];
+    if (!s || s === "/") return null;
+    const a = s.split("/").filter(Boolean);
+    if (a.length === 0) return null;
+    const r = a[0];
+    return r && this.ctx.locales.map((l) => l.code).includes(r) ? r : null;
+  }
+  /**
+   * Determines current locale from route, considering hashMode, noPrefix, prefix_and_default at /, etc.
+   */
+  getCurrentLocale(t, e) {
+    const s = this.ctx.strategy;
+    if (this.ctx.hashMode) {
+      const l = e?.();
+      return l || this.ctx.defaultLocale;
+    }
+    if (s === "no_prefix") {
+      const l = e?.();
+      return l || this.ctx.defaultLocale;
+    }
+    const a = t.path || t.fullPath || "";
+    if (s === "prefix_and_default" && (a === "/" || a === "")) {
+      const l = e?.();
+      if (l) return l;
+    }
+    if (t.params?.locale)
+      return String(t.params.locale);
+    const r = this.extractLocaleFromPath(a);
+    if (r)
+      return r;
+    if (s === "prefix_except_default")
+      return this.ctx.defaultLocale;
+    const n = e?.();
+    return n || this.ctx.defaultLocale;
+  }
+  /**
+   * Returns the route name for plugin translation loading.
+   * If disablePageLocales is true, returns 'general'.
+   */
+  getPluginRouteName(t, e) {
+    if (this.ctx.disablePageLocales)
+      return "general";
+    const s = this.getRouteBaseName(t);
+    return s || (t.name ?? "").toString().replace(this.getLocalizedRouteNamePrefix(), "").replace(new RegExp(`-${e}$`), "");
+  }
+  /**
+   * Returns displayName of the current locale, or null if not found.
+   */
+  getCurrentLocaleName(t) {
+    const e = this.getCurrentLocale(t);
+    return this.ctx.locales.find((a) => a.code === e)?.displayName ?? null;
+  }
+}
+export {
+  Qt as B,
+  wt as R,
+  jt as a,
+  Z as b,
+  M as c,
+  I as d,
+  Y as e,
+  D as f,
+  J as g,
+  K as h,
+  $t as i,
+  y as j,
+  T as k,
+  Ot as l,
+  kt as m,
+  P as n,
+  Ut as o,
+  qt as p,
+  tt as q,
+  et as r,
+  b as t,
+  Q as w
+};
+//# sourceMappingURL=base-strategy-Cf39XK8k.js.map