@i18n-micro/route-strategy 1.1.29 → 2.0.0

package/dist/paths.d.cts

@@ -0,0 +1,32 @@
+/** `a//b/` -> `a/b`; `''` and `.` -> `''`. */
+export declare function normalizePath(routePath: string): string;
+export declare const removeLeadingSlash: (routePath: string) => string;
+/** Absolute form of a path: `about` -> `/about`, `` -> `/`. */
+export declare const absolute: (routePath: string) => string;
+/** Full path of a child route: an absolute child path stands alone, a relative one is joined. */
+export declare function joinChild(parentFullPath: string, childPath: string): string;
+/**
+ * File-path and Nuxt forms of a route path to the vue-router form rules are keyed and written in:
+ * `[...slug]` -> `:slug(.*)*`, `[[page]]` -> `:page?`, `[id]` -> `:id`, `:id()` -> `:id`
+ * (non-empty matchers such as `:id(\d+)` stay).
+ */
+export declare function normalizeRouteKey(key: string): string;
+/** Lookup key of a route path or name: normalized, without the leading slash (`/` for the root). */
+export declare function routeKey(routePathOrName: string): string;
+/**
+ * Route path segment of a child from its custom value, relative to the parent's localized path.
+ * A relative value is kept as written. An absolute value is a full URL: when it starts with the
+ * parent's localized path the rest is the segment (`/konto/bestellungen` under `/konto`), the
+ * parent path itself is the empty segment, and any other value keeps what follows the segments it
+ * shares with the parent (`/bereich/artikel` under `/bereich/kategorie` is `artikel`).
+ */
+export declare function childSegment(parentLocalizedPath: string, customValue: string): string;
+/**
+ * A page path as a route rule pattern: `/artikel/:id(\\d+)` -> `/artikel/:id`, `/a/:rest(.*)*` ->
+ * `/a/**`. Null when it starts with a param: `/:slug` would match every URL of that depth.
+ */
+export declare function rulePattern(routePath: string): string | null;
+/** Whether a child's custom value is its URL: an absolute value elsewhere is nested under the parent anyway. */
+export declare function staysUnderParent(parentLocalizedPath: string, customValue: string): boolean;
+/** Percent-encoded variant of a path with such static segments (vue-router matches either). */
+export declare function encodedVariant(routePath: string): string | undefined;

package/dist/paths.d.ts

@@ -0,0 +1,32 @@
+/** `a//b/` -> `a/b`; `''` and `.` -> `''`. */
+export declare function normalizePath(routePath: string): string;
+export declare const removeLeadingSlash: (routePath: string) => string;
+/** Absolute form of a path: `about` -> `/about`, `` -> `/`. */
+export declare const absolute: (routePath: string) => string;
+/** Full path of a child route: an absolute child path stands alone, a relative one is joined. */
+export declare function joinChild(parentFullPath: string, childPath: string): string;
+/**
+ * File-path and Nuxt forms of a route path to the vue-router form rules are keyed and written in:
+ * `[...slug]` -> `:slug(.*)*`, `[[page]]` -> `:page?`, `[id]` -> `:id`, `:id()` -> `:id`
+ * (non-empty matchers such as `:id(\d+)` stay).
+ */
+export declare function normalizeRouteKey(key: string): string;
+/** Lookup key of a route path or name: normalized, without the leading slash (`/` for the root). */
+export declare function routeKey(routePathOrName: string): string;
+/**
+ * Route path segment of a child from its custom value, relative to the parent's localized path.
+ * A relative value is kept as written. An absolute value is a full URL: when it starts with the
+ * parent's localized path the rest is the segment (`/konto/bestellungen` under `/konto`), the
+ * parent path itself is the empty segment, and any other value keeps what follows the segments it
+ * shares with the parent (`/bereich/artikel` under `/bereich/kategorie` is `artikel`).
+ */
+export declare function childSegment(parentLocalizedPath: string, customValue: string): string;
+/**
+ * A page path as a route rule pattern: `/artikel/:id(\\d+)` -> `/artikel/:id`, `/a/:rest(.*)*` ->
+ * `/a/**`. Null when it starts with a param: `/:slug` would match every URL of that depth.
+ */
+export declare function rulePattern(routePath: string): string | null;
+/** Whether a child's custom value is its URL: an absolute value elsewhere is nested under the parent anyway. */
+export declare function staysUnderParent(parentLocalizedPath: string, customValue: string): boolean;
+/** Percent-encoded variant of a path with such static segments (vue-router matches either). */
+export declare function encodedVariant(routePath: string): string | undefined;

package/dist/route-generator.d.cts

@@ -0,0 +1,58 @@
+import { GlobalLocaleRoutes, Locale, Strategies } from '@i18n-micro/types';
+import { NuxtPage } from '@nuxt/schema';
+export interface RouteGeneratorOptions {
+    locales: Locale[];
+    defaultLocaleCode: string;
+    strategy: Strategies;
+    /** Custom paths by page path or route name, `$defineI18nRoute` ones merged in (config wins). */
+    globalLocaleRoutes: GlobalLocaleRoutes;
+    routeLocales?: Record<string, string[]>;
+    /** `$defineI18nRoute({ disableMeta })` by page path: baked into `meta.i18n.noMeta`. */
+    routeDisableMeta?: Record<string, boolean | string[]>;
+    noPrefixRedirect: boolean;
+    /** `redirects: false` of the module: no redirect records. */
+    redirects?: boolean;
+    excludePatterns?: (string | RegExp)[];
+    /** The translations route (`_locales` by default): pages under it stay unlocalized. */
+    apiBaseUrl?: string;
+    localizedRouteNamePrefix?: string;
+    customRegexMatcher?: string | RegExp;
+    /** Paths of the pages that nest others (`blog.vue` next to `blog/`): a relative custom value of a child hangs off them. */
+    parentPaths?: string[];
+}
+export declare class RouteGenerator {
+    readonly locales: Locale[];
+    /** Locales switched off in the config: no routes, but the runtime must know them to answer 404. */
+    readonly disabledLocales: Locale[];
+    readonly defaultLocale: Locale;
+    readonly strategy: Strategies;
+    readonly routeLocales: Record<string, string[]>;
+    /** Defaults of the domains in this build, besides the build default. */
+    private readonly hostDefaults;
+    private readonly rules;
+    private readonly options;
+    private readonly parentKeys;
+    /** Localized paths of the pages seen by the last extendPages call. */
+    private localizedPaths;
+    constructor(options: RouteGeneratorOptions);
+    /** Replaces `pages` (in place, as Nuxt's `pages:resolved` hook expects) with the localized routes. */
+    extendPages(pages: NuxtPage[]): void;
+    /**
+     * URL of a page path in a locale (custom path and prefix applied), for nitro routeRules and
+     * prerender: `/about` + `de` -> `/de/ueber-uns`. Paths the pages do not have (wildcards, API
+     * routes) only get the prefix.
+     */
+    resolveLocalizedPath(originalPath: string, localeCode: string): string;
+    private withPrefix;
+    /** A page's path in a locale without its page tree (nitro config runs first), composed as generate.ts composes it. */
+    private localizedKey;
+    /**
+     * Every URL pattern a route rule covers in a locale. A wildcard (`/blog/**`) also reaches the
+     * pages under it that moved to a custom path, and only those: `/de/artikel/:slug` for `/artikel/[slug]`.
+     */
+    resolveLocalizedRulePaths(originalPath: string, localeCode: string): string[];
+    /** Creates the global and per-page translation JSON files that do not exist yet. */
+    ensureTranslationFilesExist(pagesNames: string[], translationDir: string, rootDir: string, disablePageLocales?: boolean): void;
+    /** data.json routes to prerender: index per locale, plus one per named page unless disablePageLocales. */
+    generateDataRoutes(pages: NuxtPage[], apiBaseUrl: string, disablePageLocales: boolean): string[];
+}

package/dist/route-generator.d.ts

@@ -1,59 +1,58 @@
 import { GlobalLocaleRoutes, Locale, Strategies } from '@i18n-micro/types';
 import { NuxtPage } from '@nuxt/schema';
-import { LocalizedPathsMap } from './core/localized-paths';
-import { LocaleRoutesConfig } from './strategies/types';
 export interface RouteGeneratorOptions {
     locales: Locale[];
     defaultLocaleCode: string;
     strategy: Strategies;
+    /** Custom paths by page path or route name, `$defineI18nRoute` ones merged in (config wins). */
     globalLocaleRoutes: GlobalLocaleRoutes;
-    filesLocaleRoutes?: GlobalLocaleRoutes;
     routeLocales?: Record<string, string[]>;
+    /** `$defineI18nRoute({ disableMeta })` by page path: baked into `meta.i18n.noMeta`. */
+    routeDisableMeta?: Record<string, boolean | string[]>;
     noPrefixRedirect: boolean;
+    /** `redirects: false` of the module: no redirect records. */
+    redirects?: boolean;
     excludePatterns?: (string | RegExp)[];
+    /** The translations route (`_locales` by default): pages under it stay unlocalized. */
+    apiBaseUrl?: string;
     localizedRouteNamePrefix?: string;
     customRegexMatcher?: string | RegExp;
-    fallbackRedirectComponentPath?: string;
+    /** Paths of the pages that nest others (`blog.vue` next to `blog/`): a relative custom value of a child hangs off them. */
+    parentPaths?: string[];
 }
 export declare class RouteGenerator {
-    locales: Locale[];
-    defaultLocale: Locale;
-    strategy: Strategies;
-    localizedPaths: LocalizedPathsMap;
-    activeLocaleCodes: string[];
-    globalLocaleRoutes: LocaleRoutesConfig;
-    rawGlobalLocaleRoutes: GlobalLocaleRoutes;
-    filesLocaleRoutes: LocaleRoutesConfig;
-    routeLocales: Record<string, string[]>;
-    noPrefixRedirect: boolean;
-    excludePatterns: (string | RegExp)[] | undefined;
-    localizedRouteNamePrefix: string;
-    customRegex: string | RegExp | undefined;
-    fallbackRedirectComponentPath: string | undefined;
+    readonly locales: Locale[];
+    /** Locales switched off in the config: no routes, but the runtime must know them to answer 404. */
+    readonly disabledLocales: Locale[];
+    readonly defaultLocale: Locale;
+    readonly strategy: Strategies;
+    readonly routeLocales: Record<string, string[]>;
+    /** Defaults of the domains in this build, besides the build default. */
+    private readonly hostDefaults;
+    private readonly rules;
+    private readonly options;
+    private readonly parentKeys;
+    /** Localized paths of the pages seen by the last extendPages call. */
+    private localizedPaths;
     constructor(options: RouteGeneratorOptions);
-    private computeActiveLocaleCodes;
+    /** Replaces `pages` (in place, as Nuxt's `pages:resolved` hook expects) with the localized routes. */
     extendPages(pages: NuxtPage[]): void;
-    extractLocalizedPaths(pages: NuxtPage[], parentPath?: string): {
-        [key: string]: {
-            [locale: string]: string;
-        };
-    };
     /**
-     * Creates global and per-page translation JSON files for the current resolved locales.
-     */
-    ensureTranslationFilesExist(pagesNames: string[], translationDir: string, rootDir: string, disablePageLocales?: boolean): void;
-    private ensureFileExists;
-    /**
-     * Returns the localized path for a given URL and locale,
-     * respecting strategy and globalLocaleRoutes (custom paths).
-     * Used by nitro:config and prerender so route rules work with custom paths (e.g. /de/ueber-uns).
+     * URL of a page path in a locale (custom path and prefix applied), for nitro routeRules and
+     * prerender: `/about` + `de` -> `/de/ueber-uns`. Paths the pages do not have (wildcards, API
+     * routes) only get the prefix.
      */
     resolveLocalizedPath(originalPath: string, localeCode: string): string;
+    private withPrefix;
+    /** A page's path in a locale without its page tree (nitro config runs first), composed as generate.ts composes it. */
+    private localizedKey;
     /**
-     * Generates the list of data.json routes for prerender.
-     * When disablePageLocales is true, only index routes are generated (all pages share root translations).
-     * Otherwise, generates index + per-page routes for each locale.
+     * Every URL pattern a route rule covers in a locale. A wildcard (`/blog/**`) also reaches the
+     * pages under it that moved to a custom path, and only those: `/de/artikel/:slug` for `/artikel/[slug]`.
      */
+    resolveLocalizedRulePaths(originalPath: string, localeCode: string): string[];
+    /** Creates the global and per-page translation JSON files that do not exist yet. */
+    ensureTranslationFilesExist(pagesNames: string[], translationDir: string, rootDir: string, disablePageLocales?: boolean): void;
+    /** data.json routes to prerender: index per locale, plus one per named page unless disablePageLocales. */
     generateDataRoutes(pages: NuxtPage[], apiBaseUrl: string, disablePageLocales: boolean): string[];
-    private collectPageNames;
 }

package/dist/rules.d.cts

@@ -0,0 +1,35 @@
+import { GlobalLocaleRoutes, Locale } from '@i18n-micro/types';
+/** Custom paths of one page per locale, or `false` for a page that is not localized. */
+export type Rule = Record<string, string> | false;
+/** `true` (every locale) or the locales whose SEO tags are off. */
+export type NoMeta = boolean | string[];
+/**
+ * globalLocaleRoutes / $defineI18nRoute rules and routeLocales restrictions, keyed once by
+ * routeKey so `about/team` and `/about/team` are looked up the same way everywhere. A page is
+ * looked up by its full original path first (`about-team` / `/about-team` for a top-level page,
+ * the form without the slash winning), then by its route name, which only keys written without a
+ * leading slash can be.
+ */
+export declare class Rules {
+    private readonly rules;
+    private readonly byName;
+    private readonly restrictions;
+    private readonly restrictionsByName;
+    private readonly noMeta;
+    private readonly noMetaByName;
+    constructor(globalLocaleRoutes?: GlobalLocaleRoutes, routeLocales?: Record<string, string[]>, locales?: Locale[], routeDisableMeta?: Record<string, NoMeta>);
+    get(fullPath: string, name: string | undefined): Rule | undefined;
+    /** Locales a page may be served in, or undefined when it is not restricted. */
+    allowedLocales(fullPath: string, name: string | undefined): string[] | undefined;
+    /** `$defineI18nRoute({ disableMeta })`: SEO tags off for the page (every locale, or the listed ones). */
+    disableMeta(fullPath: string, name: string | undefined): NoMeta | undefined;
+    /** Keys of the pages at or under `base` (a route key) with a custom path in `locale`: where a wildcard rule's pages live. */
+    customKeysUnder(base: string, locale: string): string[];
+    /** Custom path of a top-level path for a locale (nitro: prerender and routeRules). */
+    customPath(fullPath: string, locale: string): string | undefined;
+}
+/**
+ * Whether `localeCode` may serve this path given `$defineI18nRoute` locales / routeLocales.
+ * Unrestricted paths (and restrictions naming no known locale) allow every locale.
+ */
+export declare function isLocaleAllowedForUnlocalizedRoute(routeLocales: Record<string, string[]>, locales: Locale[], routePath: string, localeCode: string): boolean;

package/dist/rules.d.ts

@@ -0,0 +1,35 @@
+import { GlobalLocaleRoutes, Locale } from '@i18n-micro/types';
+/** Custom paths of one page per locale, or `false` for a page that is not localized. */
+export type Rule = Record<string, string> | false;
+/** `true` (every locale) or the locales whose SEO tags are off. */
+export type NoMeta = boolean | string[];
+/**
+ * globalLocaleRoutes / $defineI18nRoute rules and routeLocales restrictions, keyed once by
+ * routeKey so `about/team` and `/about/team` are looked up the same way everywhere. A page is
+ * looked up by its full original path first (`about-team` / `/about-team` for a top-level page,
+ * the form without the slash winning), then by its route name, which only keys written without a
+ * leading slash can be.
+ */
+export declare class Rules {
+    private readonly rules;
+    private readonly byName;
+    private readonly restrictions;
+    private readonly restrictionsByName;
+    private readonly noMeta;
+    private readonly noMetaByName;
+    constructor(globalLocaleRoutes?: GlobalLocaleRoutes, routeLocales?: Record<string, string[]>, locales?: Locale[], routeDisableMeta?: Record<string, NoMeta>);
+    get(fullPath: string, name: string | undefined): Rule | undefined;
+    /** Locales a page may be served in, or undefined when it is not restricted. */
+    allowedLocales(fullPath: string, name: string | undefined): string[] | undefined;
+    /** `$defineI18nRoute({ disableMeta })`: SEO tags off for the page (every locale, or the listed ones). */
+    disableMeta(fullPath: string, name: string | undefined): NoMeta | undefined;
+    /** Keys of the pages at or under `base` (a route key) with a custom path in `locale`: where a wildcard rule's pages live. */
+    customKeysUnder(base: string, locale: string): string[];
+    /** Custom path of a top-level path for a locale (nitro: prerender and routeRules). */
+    customPath(fullPath: string, locale: string): string | undefined;
+}
+/**
+ * Whether `localeCode` may serve this path given `$defineI18nRoute` locales / routeLocales.
+ * Unrestricted paths (and restrictions naming no known locale) allow every locale.
+ */
+export declare function isLocaleAllowedForUnlocalizedRoute(routeLocales: Record<string, string[]>, locales: Locale[], routePath: string, localeCode: string): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@i18n-micro/route-strategy",
-  "version": "1.1.29",
+  "version": "2.0.0",
   "description": "Locale-aware route generator for Nuxt i18n micro",
   "keywords": [
     "i18n",
@@ -27,20 +27,13 @@
   },
   "files": [
     "dist",
-    "LICENSE",
-    "README.md"
+    "README.md",
+    "LICENSE"
   ],
   "type": "module",
   "sideEffects": false,
-  "main": "dist/index.cjs",
-  "types": "dist/index.d.ts",
-  "typesVersions": {
-    "*": {
-      ".": [
-        "./dist/index.d.ts"
-      ]
-    }
-  },
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "production": {
@@ -62,19 +55,26 @@
     "access": "public"
   },
   "dependencies": {
-    "@nuxt/schema": "^3.18.1 || ^4.5.2",
-    "@i18n-micro/core": "^1.3.22",
-    "@i18n-micro/types": "^1.2.18",
-    "@i18n-micro/utils": "^1.0.27"
+    "@i18n-micro/utils": "^2.0.0",
+    "@i18n-micro/types": "^2.0.0"
   },
   "devDependencies": {
-    "publint": "^0.3.24",
-    "vite": "^8.3.1",
-    "vite-plugin-dts": "^5.1.1",
-    "vitest": "^5.0.2"
+    "@nuxt/schema": "^3.18.0 || ^4.0.0",
+    "publint": "^0.3.25",
+    "vite": "^8.3.5",
+    "vite-plugin-dts": "^5.1.2",
+    "vitest": "^5.1.0"
+  },
+  "peerDependencies": {
+    "@nuxt/schema": "^3.18.0 || ^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@nuxt/schema": {
+      "optional": true
+    }
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "scripts": {
     "build": "vite build",

package/dist/core/alias.d.ts

@@ -1,6 +0,0 @@
-import { NuxtPage } from '@nuxt/schema';
-/**
- * Generates dedicated routes for page aliases.
- * Mirrors the legacy handleAliasRoutes behavior in the original RouteGenerator.
- */
-export declare function generateAliasRoutes(page: NuxtPage, localeCodes: string[], customRegex?: string | RegExp, localizedRouteNamePrefix?: string): NuxtPage[];

package/dist/core/builder.d.ts

@@ -1,20 +0,0 @@
-import { NuxtPage } from '@nuxt/schema';
-/**
- * Joins parent path and child segment.
- * If childSegment is absolute (starts with `/`) — returns it (normalized).
- * Otherwise, performs join(parentPath, childSegment) with normalization.
- */
-export declare function resolveChildPath(parentPath: string, childSegment: string): string;
-export interface CreateRouteOptions {
-    path: string;
-    name?: string;
-    children?: NuxtPage[];
-    meta?: Record<string, unknown>;
-    /** When undefined, alias is cleared (for the main localized route when alias routes are created separately). */
-    alias?: string[] | undefined;
-}
-/**
- * Creates a new NuxtPage object from the original page and provided options.
- * Copies meta, component, file, etc.; provided options override the respective fields.
- */
-export declare function createRoute(page: NuxtPage, options: CreateRouteOptions): NuxtPage;

package/dist/core/context.d.ts

@@ -1,53 +0,0 @@
-import { GlobalLocaleRoutes, Locale, Strategies } from '@i18n-micro/types';
-import { NuxtPage } from '@nuxt/schema';
-import { LocaleRoutesConfig } from '../strategies/types';
-import { LocalizedPathsMap } from './localized-paths';
-export interface GeneratorContextOptions {
-    locales: Locale[];
-    defaultLocaleCode: string;
-    strategy: Strategies;
-    globalLocaleRoutes: GlobalLocaleRoutes;
-    filesLocaleRoutes: LocaleRoutesConfig;
-    routeLocales: Record<string, string[]>;
-    pages: NuxtPage[];
-    excludePatterns?: (string | RegExp)[];
-    customRegex?: string | RegExp;
-    noPrefixRedirect?: boolean;
-    localizedRouteNamePrefix?: string;
-    /** Resolved path to the locale-redirect component for prefix strategy fallback route. */
-    fallbackRedirectComponentPath?: string;
-    /** Raw globalLocaleRoutes for fallback route meta (locale-redirect component). */
-    rawGlobalLocaleRoutes?: GlobalLocaleRoutes;
-}
-export declare class GeneratorContext {
-    readonly locales: Locale[];
-    readonly defaultLocale: Locale;
-    readonly strategy: Strategies;
-    readonly globalLocaleRoutes: LocaleRoutesConfig;
-    readonly filesLocaleRoutes: LocaleRoutesConfig;
-    readonly routeLocales: Record<string, string[]>;
-    readonly localizedPaths: LocalizedPathsMap;
-    readonly activeLocaleCodes: string[];
-    readonly excludePatterns: (string | RegExp)[] | undefined;
-    readonly customRegex: string | RegExp | undefined;
-    readonly noPrefixRedirect: boolean;
-    readonly localizedRouteNamePrefix: string;
-    readonly fallbackRedirectComponentPath: string | undefined;
-    readonly rawGlobalLocaleRoutes: GlobalLocaleRoutes | undefined;
-    constructor(options: GeneratorContextOptions);
-    private findLocaleByCode;
-    /**
-     * Returns the list of locale codes allowed for a page (respecting routeLocales).
-     */
-    getAllowedLocales(pagePath: string, pageName: string): string[];
-    /**
-     * Returns a custom path for a given locale by original page path, if any.
-     */
-    getCustomPath(originalPath: string, localeCode: string): string | undefined;
-    /**
-     * Returns a map of custom paths (locale → path) for a page by path key or name.
-     */
-    getCustomPathsForPage(originalPath: string, pageName: string): Record<string, string> | undefined;
-    hasLocaleRestrictions(pagePath: string, pageName: string): boolean;
-    filterLocaleCodesWithoutCustomPaths(fullPath: string): string[];
-}

package/dist/core/localization-disabled.d.ts

@@ -1,3 +0,0 @@
-import { LocaleRoutesConfig } from '../strategies/types';
-/** True when localization is disabled via `globalLocaleRoutes[key] === false`. */
-export declare function isLocalizationDisabledForPage(globalLocaleRoutes: LocaleRoutesConfig, originalPath: string, pageName: string): boolean;

package/dist/core/localized-paths.d.ts

@@ -1,20 +0,0 @@
-import { NuxtPage } from '@nuxt/schema';
-import { LocaleRoutesConfig } from '../strategies/types';
-export type LocalizedPathsMap = Record<string, Record<string, string>>;
-/**
- * Single key format for localizedPaths: without a leading slash so that it
- * matches:
- * - keys from the Nuxt module (routePath from page files),
- * - and lookups from strategies (resolveChildPath results).
- */
-export declare function pathKeyForLocalizedPaths(fullPath: string): string;
-/**
- * Extracts a map of custom paths (path key → locale → path) from:
- * - pages,
- * - globalLocaleRoutes,
- * - filesLocaleRoutes.
- *
- * Walks children recursively. Keys are stored without a leading slash for
- * compatibility with the Nuxt module and strategies.
- */
-export declare function extractLocalizedPaths(pages: NuxtPage[], globalLocaleRoutes: LocaleRoutesConfig, filesLocaleRoutes: LocaleRoutesConfig, parentPath?: string): LocalizedPathsMap;

package/dist/locale-route-access.d.ts

@@ -1,6 +0,0 @@
-import { Locale } from '@i18n-micro/types';
-/**
- * Whether `localeCode` may serve this path given `$defineI18nRoute` / `routeLocales`.
- * When no restriction applies for the path, returns true for every locale (matches runtime path-strategy).
- */
-export declare function isLocaleAllowedForUnlocalizedRoute(routeLocales: Record<string, string[]>, locales: Locale[], unlocalizedPath: string, localeCode: string): boolean;

package/dist/strategies/abstract.d.ts

@@ -1,30 +0,0 @@
-import { NuxtPage } from '@nuxt/schema';
-import { GeneratorContext } from '../core/context';
-import { RouteStrategy } from './types';
-export declare abstract class BaseStrategy implements RouteStrategy {
-    processPage(page: NuxtPage, context: GeneratorContext): NuxtPage[];
-    postProcess(pages: NuxtPage[], _context: GeneratorContext): NuxtPage[];
-    protected abstract generateVariants(page: NuxtPage, context: GeneratorContext): NuxtPage[];
-    /**
-     * Recursive localization for children: for a given locale, builds:
-     * - parentOriginalPath used for Context lookups,
-     * - parentLocalizedPath used for the final path,
-     * and returns an array of localized child routes.
-     */
-    protected localizeChildren(children: NuxtPage[], parentLocalizedPath: string, parentOriginalPath: string, locale: string, context: GeneratorContext, addPrefix: boolean): NuxtPage[];
-    /**
-     * Variant for a single route with :locale(locale1|locale2) — without custom paths.
-     * Returns a single child route with a relative path and recursively localized children.
-     */
-    protected localizeChildrenAllLocales(children: NuxtPage[], parentPath: string, parentOriginalPath: string, localeCodes: string[], context: GeneratorContext): NuxtPage[];
-    private localizeChildAllLocales;
-    private localizeChild;
-    /**
-     * Shared helper for strategies that build prefix-based paths (:locale(...)):
-     * - for custom paths, decides whether a prefix is required,
-     * - for regular paths, always uses buildFullPath.
-     *
-     * The logic matches what used to be duplicated in each strategy's buildRoutePath.
-     */
-    protected buildRoutePathForLocales(localeCodes: string[], originalPath: string, customPath: string, isCustom: boolean, customRegex: string | RegExp | undefined, force: boolean, defaultLocaleCode: string): string;
-}

package/dist/strategies/factory.d.ts

@@ -1,3 +0,0 @@
-import { Strategies } from '@i18n-micro/types';
-import { RouteStrategy } from './types';
-export declare function getStrategy(name: Strategies): RouteStrategy;

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

@@ -1,13 +0,0 @@
-import { NuxtPage } from '@nuxt/schema';
-import { GeneratorContext } from '../core/context';
-import { BaseStrategy } from './abstract';
-export declare class NoPrefixStrategy extends BaseStrategy {
-    protected generateVariants(page: NuxtPage, context: GeneratorContext): NuxtPage[];
-    /**
-     * Localizes the children tree for the no_prefix strategy.
-     * Mirrors the behavior of the legacy RouteGenerator:
-     * - on the first level, custom paths (globalLocaleRoutes/filesLocaleRoutes) are applied;
-     * - on deeper levels, path stays as a segment (item, detail, etc.).
-     */
-    private localizeChildrenForNoPrefix;
-}

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

@@ -1,8 +0,0 @@
-import { NuxtPage } from '@nuxt/schema';
-import { GeneratorContext } from '../core/context';
-import { BaseStrategy } from './abstract';
-export declare class PrefixAndDefaultStrategy extends BaseStrategy {
-    protected generateVariants(page: NuxtPage, context: GeneratorContext): NuxtPage[];
-    postProcess(pages: NuxtPage[], context: GeneratorContext): NuxtPage[];
-    private createLocalizedRoute;
-}

package/dist/strategies/prefix-except-default.d.ts

@@ -1,12 +0,0 @@
-import { NuxtPage } from '@nuxt/schema';
-import { GeneratorContext } from '../core/context';
-import { BaseStrategy } from './abstract';
-export declare class PrefixExceptDefaultStrategy extends BaseStrategy {
-    protected generateVariants(page: NuxtPage, context: GeneratorContext): NuxtPage[];
-    postProcess(pages: NuxtPage[], context: GeneratorContext): NuxtPage[];
-    private createLocalizedChildren;
-    private createLocalizedVariants;
-    private buildChildRouteName;
-    private createLocalizedRoute;
-    private buildLocalizedRouteName;
-}

package/dist/strategies/prefix.d.ts

@@ -1,7 +0,0 @@
-import { NuxtPage } from '@nuxt/schema';
-import { GeneratorContext } from '../core/context';
-import { BaseStrategy } from './abstract';
-export declare class PrefixStrategy extends BaseStrategy {
-    protected generateVariants(page: NuxtPage, context: GeneratorContext): NuxtPage[];
-    postProcess(pages: NuxtPage[], context: GeneratorContext): NuxtPage[];
-}

package/dist/strategies/types.d.ts

@@ -1,17 +0,0 @@
-import { NuxtPage } from '@nuxt/schema';
-import { GeneratorContext } from '../core/context';
-export interface RouteStrategy {
-    /**
-     * Processes a page and returns an array of routes (base + aliases, etc.).
-     */
-    processPage(page: NuxtPage, context: GeneratorContext): NuxtPage[];
-    /**
-     * Post-processes the full pages array (e.g. removing unprefixed routes).
-     */
-    postProcess(pages: NuxtPage[], context: GeneratorContext): NuxtPage[];
-}
-/**
- * Shared type for global/files-level locale routes configuration.
- * Used in Context and RouteGenerator to avoid repeating the same signature.
- */
-export type LocaleRoutesConfig = Record<string, Record<string, string> | false | boolean>;

package/dist/utils/common.d.ts

@@ -1,9 +0,0 @@
-import { Locale } from '@i18n-micro/types';
-import { NuxtPage } from '@nuxt/schema';
-export { isInternalPath } from '@i18n-micro/utils/app-path';
-export declare const cloneArray: <T extends object>(array: T[]) => T[];
-export declare const isPageRedirectOnly: (page: NuxtPage) => boolean;
-export declare const buildRouteName: (baseName: string, localeCode: string, isCustom: boolean, prefix?: string) => string;
-export declare const buildRouteNameFromRoute: (name: string | null | undefined, routePath: string | null | undefined) => string;
-export declare const shouldAddLocalePrefix: (locale: string, defaultLocale: Locale, addLocalePrefix: boolean) => boolean;
-export declare const isLocaleDefault: (locale: string | Locale, defaultLocale: Locale) => boolean;

package/dist/utils/index.d.cts

@@ -1,3 +0,0 @@
-export { buildRouteName, buildRouteNameFromRoute, cloneArray, isInternalPath, isLocaleDefault, isPageRedirectOnly, shouldAddLocalePrefix, } from './common';
-export { type ResolvedLocales, resolveLocales } from './locales';
-export { buildEncodedPathAliases, buildFullPath, buildFullPathNoPrefix, joinPath, normalizePath, normalizeRouteKey, removeLeadingSlash } from './path';

package/dist/utils/index.d.ts

@@ -1,3 +0,0 @@
-export { buildRouteName, buildRouteNameFromRoute, cloneArray, isInternalPath, isLocaleDefault, isPageRedirectOnly, shouldAddLocalePrefix, } from './common';
-export { type ResolvedLocales, resolveLocales } from './locales';
-export { buildEncodedPathAliases, buildFullPath, buildFullPathNoPrefix, joinPath, normalizePath, normalizeRouteKey, removeLeadingSlash } from './path';

package/dist/utils/locales.d.ts

@@ -1,9 +0,0 @@
-import { Locale } from '@i18n-micro/types';
-export interface ResolvedLocales {
-    locales: Locale[];
-    defaultLocale: Locale;
-}
-/**
- * Merges locale list (dedupe by code, merge props) and filters out disabled locales.
- */
-export declare function resolveLocales(locales: Locale[], defaultLocaleCode: string): ResolvedLocales;

package/dist/utils/path.d.ts

@@ -1,8 +0,0 @@
-export declare function normalizeRouteKey(key: string): string;
-export declare const normalizePath: (routePath: string) => string;
-export declare const removeLeadingSlash: (routePath: string) => string;
-export declare function joinPath(...segments: string[]): string;
-/** Alias paths for percent-encoded variants of non-ASCII localized routes. */
-export declare function buildEncodedPathAliases(routePath: string): string[];
-export declare function buildFullPath(locale: string | string[], basePath: string, customRegex?: string | RegExp): string;
-export declare function buildFullPathNoPrefix(basePath: string): string;