@i18n-micro/route-strategy 1.1.0

package/dist/route-generator.d.ts

@@ -0,0 +1,56 @@
+import { NuxtPage } from '@nuxt/schema';
+import { GlobalLocaleRoutes, Locale, Strategies } from '@i18n-micro/types';
+import { LocaleRoutesConfig } from './strategies/types';
+import { LocalizedPathsMap } from './core/localized-paths';
+export interface RouteGeneratorOptions {
+    locales: Locale[];
+    defaultLocaleCode: string;
+    strategy: Strategies;
+    globalLocaleRoutes: GlobalLocaleRoutes;
+    filesLocaleRoutes?: GlobalLocaleRoutes;
+    routeLocales?: Record<string, string[]>;
+    noPrefixRedirect: boolean;
+    excludePatterns?: (string | RegExp)[];
+    localizedRouteNamePrefix?: string;
+    customRegexMatcher?: string | RegExp;
+    fallbackRedirectComponentPath?: 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;
+    constructor(options: RouteGeneratorOptions);
+    private computeActiveLocaleCodes;
+    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).
+     */
+    resolveLocalizedPath(originalPath: string, localeCode: string): string;
+    /**
+     * Generates the list of data.json routes for prerender (general + per-page per locale).
+     */
+    generateDataRoutes(pages: NuxtPage[], apiBaseUrl: string, disablePageLocales: boolean): string[];
+}

package/dist/strategies/abstract.d.ts

@@ -0,0 +1,30 @@
+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

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

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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,9 @@
+import { NuxtPage } from '@nuxt/schema';
+import { Locale } from '@i18n-micro/types';
+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, includeDefaultLocaleRoute: boolean) => boolean;
+export declare const isLocaleDefault: (locale: string | Locale, defaultLocale: Locale, includeDefaultLocaleRoute: boolean) => boolean;
+export declare function isInternalPath(path: string, excludePatterns?: (string | RegExp | object)[]): boolean;

package/dist/utils/index.d.ts

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

package/dist/utils/locales.d.ts

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,6 @@
+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;
+export declare function buildFullPath(locale: string | string[], basePath: string, customRegex?: string | RegExp): string;
+export declare function buildFullPathNoPrefix(basePath: string): string;

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@i18n-micro/route-strategy",
+  "version": "1.1.0",
+  "description": "Locale-aware route generator for Nuxt i18n micro",
+  "type": "module",
+  "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"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/index.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "i18n",
+    "nuxt",
+    "routes",
+    "locale",
+    "route-generator",
+    "internationalization"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/s00d/nuxt-i18n-micro.git",
+    "directory": "packages/route-generator"
+  },
+  "homepage": "https://github.com/s00d/nuxt-i18n-micro/tree/main/packages/route-generator#readme",
+  "bugs": {
+    "url": "https://github.com/s00d/nuxt-i18n-micro/issues"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "s00d",
+    "email": "Virus191288@gmail.com",
+    "url": "https://s00d.github.io/"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "@nuxt/schema": "^3.18.1 || ^4.0.0",
+    "@i18n-micro/types": "1.1.0",
+    "@i18n-micro/core": "1.1.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.4.6",
+    "vite": "^7.3.1",
+    "vite-plugin-dts": "^4.5.4"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "vite build",
+    "test": "jest"
+  }
+}