@i18n-micro/path-strategy 1.0.0

package/dist/prefix-strategy.d.ts

@@ -0,0 +1,277 @@
+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;
+}
+
+/** 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;
+}
+
+declare class PrefixPathStrategy extends BasePathStrategy {
+    protected buildLocalizedPath(path: string, locale: string, _isCustom: boolean): string;
+    protected buildLocalizedRouteName(baseName: string, locale: string): string;
+    getCanonicalPath(route: ResolvedRouteLike, targetLocale: string): string | null;
+    resolveLocaleFromPath(path: string): string | null;
+    getRedirect(currentPath: string, detectedLocale: string): string | null;
+    private buildPathWithPrefix;
+}
+export { PrefixPathStrategy }
+export { PrefixPathStrategy as Strategy }
+
+/** 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/prefix-strategy.mjs

@@ -0,0 +1,40 @@
+import { B as u, j as c, n as P, c as l, w as m, a as g, g as d, i as f } from "./base-strategy-DVqe8ehd.js";
+class S extends u {
+  buildLocalizedPath(a, e, t) {
+    return c(e, P(a));
+  }
+  buildLocalizedRouteName(a, e) {
+    return this.buildLocalizedName(a, e);
+  }
+  getCanonicalPath(a, e) {
+    const t = this.getCustomPathSegment(a, e);
+    if (!t) return null;
+    const s = t.startsWith("/") ? t : `/${t}`;
+    return l(`/${e}${s}`);
+  }
+  resolveLocaleFromPath(a) {
+    const { localeFromPath: e } = this.getPathWithoutLocale(a);
+    return e;
+  }
+  getRedirect(a, e) {
+    const { pathWithoutLocale: t, localeFromPath: s } = this.getPathWithoutLocale(a), r = this.ctx.globalLocaleRoutes, n = t === "/" ? "/" : m(t), o = r && (r[t] === !1 || r[n] === !1);
+    if (o && s !== null)
+      return g(t);
+    if (o && s === null)
+      return null;
+    const i = this.buildPathWithPrefix(t, e), h = d(a);
+    return s === e && f(h, i) ? null : i;
+  }
+  buildPathWithPrefix(a, e) {
+    const t = this.resolvePathForLocale(a, e);
+    if (t === "/" || t === "")
+      return `/${e}`;
+    const s = `/${e}`, r = t.startsWith("/") ? t : `/${t}`;
+    return l(s + r);
+  }
+}
+export {
+  S as PrefixPathStrategy,
+  S as Strategy
+};
+//# sourceMappingURL=prefix-strategy.mjs.map

package/dist/prefix-strategy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefix-strategy.mjs","sources":["../src/strategies/prefix.ts"],"sourcesContent":["import type { ResolvedRouteLike } from '../core/types'\nimport { BasePathStrategy } from './base-strategy'\nimport { cleanDoubleSlashes, isSamePath, withoutLeadingSlash } from 'ufo'\nimport { getCleanPath, joinUrl, normalizePath, normalizePathForCompare } from '../utils/path'\n\nexport class PrefixPathStrategy 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 getCanonicalPath(route: ResolvedRouteLike, targetLocale: string): string | null {\n    const segment = this.getCustomPathSegment(route, targetLocale)\n    if (!segment) return null\n    const normalized = segment.startsWith('/') ? segment : `/${segment}`\n    return cleanDoubleSlashes(`/${targetLocale}${normalized}`)\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    const gr = this.ctx.globalLocaleRoutes\n    const pathKey = pathWithoutLocale === '/' ? '/' : withoutLeadingSlash(pathWithoutLocale)\n    const isUnlocalized = gr && (gr[pathWithoutLocale] === false || gr[pathKey] === false)\n    if (isUnlocalized && localeFromPath !== null) {\n      return normalizePathForCompare(pathWithoutLocale)\n    }\n    if (isUnlocalized && localeFromPath === null) {\n      return null\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    const prefix = `/${locale}`\n    const withSlash = resolved.startsWith('/') ? resolved : `/${resolved}`\n    return cleanDoubleSlashes(prefix + withSlash)\n  }\n}\n\n/** Alias for Nuxt alias consumption: only this strategy is bundled when importing from #i18n-strategy. */\nexport { PrefixPathStrategy as Strategy }\n"],"names":["PrefixPathStrategy","BasePathStrategy","path","locale","_isCustom","joinUrl","normalizePath","baseName","route","targetLocale","segment","normalized","cleanDoubleSlashes","localeFromPath","currentPath","detectedLocale","pathWithoutLocale","gr","pathKey","withoutLeadingSlash","isUnlocalized","normalizePathForCompare","expectedPath","currentPathOnly","getCleanPath","isSamePath","resolved","prefix","withSlash"],"mappings":";AAKO,MAAMA,UAA2BC,EAAiB;AAAA,EAC7C,mBAAmBC,GAAcC,GAAgBC,GAA4B;AACrF,WAAOC,EAAQF,GAAQG,EAAcJ,CAAI,CAAC;AAAA,EAC5C;AAAA,EAEU,wBAAwBK,GAAkBJ,GAAwB;AAC1E,WAAO,KAAK,mBAAmBI,GAAUJ,CAAM;AAAA,EACjD;AAAA,EAES,iBAAiBK,GAA0BC,GAAqC;AACvF,UAAMC,IAAU,KAAK,qBAAqBF,GAAOC,CAAY;AAC7D,QAAI,CAACC,EAAS,QAAO;AACrB,UAAMC,IAAaD,EAAQ,WAAW,GAAG,IAAIA,IAAU,IAAIA,CAAO;AAClE,WAAOE,EAAmB,IAAIH,CAAY,GAAGE,CAAU,EAAE;AAAA,EAC3D;AAAA,EAEA,sBAAsBT,GAA6B;AACjD,UAAM,EAAE,gBAAAW,EAAA,IAAmB,KAAK,qBAAqBX,CAAI;AACzD,WAAOW;AAAA,EACT;AAAA,EAEA,YAAYC,GAAqBC,GAAuC;AACtE,UAAM,EAAE,mBAAAC,GAAmB,gBAAAH,EAAA,IAAmB,KAAK,qBAAqBC,CAAW,GAC7EG,IAAK,KAAK,IAAI,oBACdC,IAAUF,MAAsB,MAAM,MAAMG,EAAoBH,CAAiB,GACjFI,IAAgBH,MAAOA,EAAGD,CAAiB,MAAM,MAASC,EAAGC,CAAO,MAAM;AAChF,QAAIE,KAAiBP,MAAmB;AACtC,aAAOQ,EAAwBL,CAAiB;AAElD,QAAII,KAAiBP,MAAmB;AACtC,aAAO;AAET,UAAMS,IAAe,KAAK,oBAAoBN,GAAmBD,CAAc,GACzEQ,IAAkBC,EAAaV,CAAW;AAChD,WAAID,MAAmBE,KAAkBU,EAAWF,GAAiBD,CAAY,IACxE,OAEFA;AAAA,EACT;AAAA,EAEQ,oBAAoBN,GAA2Bb,GAAwB;AAC7E,UAAMuB,IAAW,KAAK,qBAAqBV,GAAmBb,CAAM;AACpE,QAAIuB,MAAa,OAAOA,MAAa;AACnC,aAAO,IAAIvB,CAAM;AAEnB,UAAMwB,IAAS,IAAIxB,CAAM,IACnByB,IAAYF,EAAS,WAAW,GAAG,IAAIA,IAAW,IAAIA,CAAQ;AACpE,WAAOd,EAAmBe,IAASC,CAAS;AAAA,EAC9C;AACF;"}

package/dist/types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=types.cjs.map

package/dist/types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/types.d.ts

@@ -0,0 +1,108 @@
+import { I18nRouteParams } from '@i18n-micro/types';
+import { Locale } from '@i18n-micro/types';
+import { Strategies } from '@i18n-micro/types';
+
+/** Custom path rules: route key -> locale -> path segment. false = unlocalized route. */
+declare type GlobalLocaleRoutes = Record<string, Record<string, string> | false>;
+
+export declare interface HreflangTag {
+    rel: 'alternate';
+    href: string;
+    hreflang: string;
+}
+
+export declare interface PathStrategy {
+    /**
+     * Returns a route object to navigate to another locale from the current page.
+     */
+    switchLocaleRoute(fromLocale: string, toLocale: string, route: ResolvedRouteLike, options: SwitchLocaleOptions): RouteLike | string;
+    /**
+     * Localizes the given route (object or string) for the target locale.
+     * Always returns RouteLike (path and fullPath set). Analogue of $localeRoute / resolveLocalizedRoute.
+     */
+    localeRoute(targetLocale: string, routeOrPath: RouteLike | string, currentRoute?: ResolvedRouteLike): RouteLike;
+    /**
+     * Checks if there is a custom path for the given route in globalLocaleRoutes.
+     * Used by redirect logic. Returns a path or null.
+     */
+    getCanonicalPath(route: ResolvedRouteLike, targetLocale: string): string | null;
+    /**
+     * Determines locale from URL path (strategy-specific).
+     * Returns locale code or null if path does not contain a locale (e.g. no_prefix).
+     */
+    resolveLocaleFromPath(path: string): string | null;
+    /**
+     * Tries to determine locale from URL path (first segment).
+     * Used for initial state and redirect logic. Base implementation in BasePathStrategy.
+     */
+    getLocaleFromPath(path: string): string | null;
+    /**
+     * Returns path to redirect to for the given current path and target locale, or null if no redirect needed.
+     * Use in middleware: const redirectPath = strategy.getRedirect(to.fullPath, detectedLocale)
+     */
+    getRedirect(currentPath: string, targetLocale: string): string | null;
+    /**
+     * 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;
+}
+
+export 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). */
+export declare interface ResolvedRouteLike extends RouteLike {
+    name: string | null;
+    path: string;
+    fullPath: string;
+}
+
+/** Route-like shape (compatible with vue-router). */
+export declare interface RouteLike {
+    name?: string | null;
+    path?: string;
+    params?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    hash?: string;
+    fullPath?: string;
+}
+
+export declare interface RouterAdapter {
+    hasRoute: (name: string) => boolean;
+    resolve: (to: RouteLike | string) => ResolvedRouteLike;
+    getRoutes?: () => unknown[];
+}
+
+export declare interface SeoAttributes {
+    canonical?: string;
+    hreflangs?: HreflangTag[];
+}
+
+export declare interface SwitchLocaleOptions {
+    i18nRouteParams?: I18nRouteParams;
+}
+
+export { }

package/dist/types.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=types.mjs.map

package/dist/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "@i18n-micro/path-strategy",
+  "version": "1.0.0",
+  "description": "Shared strategy-based path and route name builder for Nuxt I18n Micro frontend routing.",
+  "repository": "s00d/nuxt-i18n-micro",
+  "license": "MIT",
+  "type": "module",
+  "author": {
+    "name": "s00d",
+    "email": "Virus191288@gmail.com",
+    "url": "https://s00d.github.io/"
+  },
+  "homepage": "https://github.com/s00d/nuxt-i18n-micro",
+  "bugs": {
+    "url": "https://github.com/s00d/nuxt-i18n-micro/issues"
+  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.mjs"
+    },
+    "./prefix": {
+      "types": "./dist/prefix-strategy.d.ts",
+      "import": "./dist/prefix-strategy.mjs",
+      "require": "./dist/prefix-strategy.cjs",
+      "default": "./dist/prefix-strategy.mjs"
+    },
+    "./no-prefix": {
+      "types": "./dist/no-prefix-strategy.d.ts",
+      "import": "./dist/no-prefix-strategy.mjs",
+      "require": "./dist/no-prefix-strategy.cjs",
+      "default": "./dist/no-prefix-strategy.mjs"
+    },
+    "./prefix-except-default": {
+      "types": "./dist/prefix-except-default-strategy.d.ts",
+      "import": "./dist/prefix-except-default-strategy.mjs",
+      "require": "./dist/prefix-except-default-strategy.cjs",
+      "default": "./dist/prefix-except-default-strategy.mjs"
+    },
+    "./prefix-and-default": {
+      "types": "./dist/prefix-and-default-strategy.d.ts",
+      "import": "./dist/prefix-and-default-strategy.mjs",
+      "require": "./dist/prefix-and-default-strategy.cjs",
+      "default": "./dist/prefix-and-default-strategy.mjs"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.mjs",
+      "require": "./dist/types.cjs",
+      "default": "./dist/types.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "nuxt",
+    "i18n",
+    "routing",
+    "paths",
+    "strategy"
+  ],
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "ufo": "^1.5.4",
+    "@i18n-micro/types": "1.1.0"
+  },
+  "devDependencies": {
+    "vite": "^7.3.1",
+    "vite-plugin-dts": "^4.5.4"
+  },
+  "scripts": {
+    "build": "vite build",
+    "test": "jest"
+  }
+}