@modern-js/plugin-i18n 3.3.0 → 3.5.0

package/dist/esm-node/cli/locales.mjs

@@ -0,0 +1,81 @@
+import "node:module";
+import fs from "fs";
+import path from "path";
+import { getPublicDirRoutePrefixes, normalizePublicDir, normalizePublicDirPath } from "@modern-js/server-core";
+const LOCALES_RESOURCE_PATTERN = '{{lng}}/{{ns}}.json';
+function hasJsonFiles(dirPath) {
+    try {
+        if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory()) return false;
+        const entries = fs.readdirSync(dirPath);
+        for (const entry of entries){
+            const entryPath = path.join(dirPath, entry);
+            const stat = fs.statSync(entryPath);
+            if (stat.isFile() && entry.endsWith('.json')) return true;
+            if (stat.isDirectory() && hasJsonFiles(entryPath)) return true;
+        }
+        return false;
+    } catch  {
+        return false;
+    }
+}
+function toPosixPath(filePath) {
+    return filePath.split(path.sep).join(path.posix.sep);
+}
+function getPublicDirOutputPath(publicDir) {
+    return normalizePublicDirPath(publicDir);
+}
+function buildDetectedLocalesDirectory(clientBasePath, serverBasePath, serverBasePathCandidates = [
+    serverBasePath
+]) {
+    const normalizedClientBasePath = clientBasePath.startsWith('/') ? clientBasePath : `/${clientBasePath}`;
+    const normalizedServerBasePath = toPosixPath(serverBasePath).replace(/\/$/, '');
+    const normalizedServerBasePathCandidates = Array.from(new Set(serverBasePathCandidates.map((candidate)=>toPosixPath(candidate).replace(/\/$/, ''))));
+    const serverLoadPaths = normalizedServerBasePathCandidates.map((candidate)=>`${candidate}/${LOCALES_RESOURCE_PATTERN}`);
+    const serverAddPaths = normalizedServerBasePathCandidates.map((candidate)=>`${candidate}/${LOCALES_RESOURCE_PATTERN}`);
+    return {
+        loadPath: `${normalizedClientBasePath}/${LOCALES_RESOURCE_PATTERN}`,
+        addPath: `${normalizedClientBasePath}/${LOCALES_RESOURCE_PATTERN}`,
+        serverLoadPath: `${normalizedServerBasePath}/${LOCALES_RESOURCE_PATTERN}`,
+        serverAddPath: `${normalizedServerBasePath}/${LOCALES_RESOURCE_PATTERN}`,
+        serverLoadPaths,
+        serverAddPaths
+    };
+}
+function detectLocalesDirectory(appDirectory, normalizedConfig) {
+    const publicDirs = normalizePublicDir(normalizedConfig?.server?.publicDir);
+    const publicDirPrefixes = getPublicDirRoutePrefixes(normalizedConfig?.server?.publicDir);
+    for(let index = 0; index < publicDirs.length; index++){
+        const publicDir = publicDirs[index];
+        if (path.isAbsolute(publicDir)) continue;
+        const publicDirPath = path.join(appDirectory, publicDir);
+        const publicDirPrefix = publicDirPrefixes[index] || `/${normalizePublicDirPath(publicDir)}`;
+        const publicDirOutputPath = getPublicDirOutputPath(publicDir);
+        if ('locales' === path.basename(normalizePublicDirPath(publicDir)) && hasJsonFiles(publicDirPath)) return buildDetectedLocalesDirectory(publicDirPrefix, `./${publicDirOutputPath}`);
+        const localesPath = path.join(publicDirPath, 'locales');
+        if (hasJsonFiles(localesPath)) return buildDetectedLocalesDirectory(`${publicDirPrefix}/locales`, `./${publicDirOutputPath}/locales`);
+    }
+    const configPublicPath = path.join(appDirectory, 'config', 'public', 'locales');
+    if (hasJsonFiles(configPublicPath)) return buildDetectedLocalesDirectory('/locales', './public/locales', [
+        './config/public/locales',
+        './public/locales'
+    ]);
+    const rootLocalesPath = path.join(appDirectory, 'locales');
+    if (hasJsonFiles(rootLocalesPath)) return buildDetectedLocalesDirectory('/locales', './locales');
+}
+function applyDetectedBackendPaths(backendOptions, detectedLocales) {
+    if (!detectedLocales) return backendOptions;
+    const backendWithDetectedPaths = {
+        ...backendOptions,
+        enabled: true,
+        loadPath: backendOptions.loadPath ?? detectedLocales.loadPath,
+        addPath: backendOptions.addPath ?? detectedLocales.addPath,
+        serverLoadPath: backendOptions.serverLoadPath ?? detectedLocales.serverLoadPath,
+        serverLoadPaths: backendOptions.serverLoadPath || backendOptions.serverLoadPaths ? backendOptions.serverLoadPaths : detectedLocales.serverLoadPaths,
+        serverAddPath: backendOptions.serverAddPath ?? detectedLocales.serverAddPath,
+        serverAddPaths: backendOptions.serverAddPath || backendOptions.serverAddPaths ? backendOptions.serverAddPaths : detectedLocales.serverAddPaths,
+        _detectedLoadPath: detectedLocales.loadPath,
+        _detectedAddPath: detectedLocales.addPath
+    };
+    return backendWithDetectedPaths;
+}
+export { applyDetectedBackendPaths, detectLocalesDirectory };

package/dist/esm-node/runtime/i18n/backend/defaults.mjs

@@ -4,8 +4,6 @@ const DEFAULT_I18NEXT_BACKEND_OPTIONS = {
     addPath: '/locales/{{lng}}/{{ns}}.json'
 };
 function convertPath(path) {
-    if (!path) return path;
-    if (path.startsWith('/')) return `${window.__assetPrefix__ || ''}${path}`;
     return path;
 }
 function convertBackendOptions(options) {
@@ -13,6 +11,12 @@ function convertBackendOptions(options) {
     const converted = {
         ...options
     };
+    delete converted.serverLoadPath;
+    delete converted.serverAddPath;
+    delete converted.serverLoadPaths;
+    delete converted.serverAddPaths;
+    delete converted._detectedLoadPath;
+    delete converted._detectedAddPath;
     if (converted.loadPath) converted.loadPath = convertPath(converted.loadPath);
     if (converted.addPath) converted.addPath = convertPath(converted.addPath);
     return converted;

package/dist/esm-node/runtime/i18n/backend/defaults.node.mjs

@@ -1,4 +1,5 @@
 import "node:module";
+import fs from "fs";
 const DEFAULT_I18NEXT_BACKEND_OPTIONS = {
     loadPath: './locales/{{lng}}/{{ns}}.json',
     addPath: './locales/{{lng}}/{{ns}}.json'
@@ -8,13 +9,43 @@ function convertPath(path) {
     if (path.startsWith('/')) return `.${path}`;
     return path;
 }
+function shouldUseServerPath(currentPath, detectedPath) {
+    return !detectedPath || currentPath === detectedPath;
+}
+function getResourceBasePath(resourcePath) {
+    const markerIndex = resourcePath.indexOf('{{lng}}');
+    if (markerIndex < 0) return resourcePath;
+    return resourcePath.slice(0, markerIndex).replace(/[\\/]+$/, '');
+}
+function pathExists(resourcePath) {
+    try {
+        return fs.existsSync(getResourceBasePath(resourcePath));
+    } catch  {
+        return false;
+    }
+}
+function getServerPath(pathCandidates, fallbackPath) {
+    const candidates = Array.from(new Set([
+        ...pathCandidates || [],
+        fallbackPath
+    ].filter(Boolean)));
+    return candidates.find(pathExists) || candidates[0];
+}
 function convertBackendOptions(options) {
     if (!options) return options;
     const converted = {
         ...options
     };
-    if (converted.loadPath) converted.loadPath = convertPath(converted.loadPath);
-    if (converted.addPath) converted.addPath = convertPath(converted.addPath);
+    if ((converted.serverLoadPath || converted.serverLoadPaths) && shouldUseServerPath(converted.loadPath, converted._detectedLoadPath)) converted.loadPath = getServerPath(converted.serverLoadPaths, converted.serverLoadPath);
+    else if (converted.loadPath) converted.loadPath = convertPath(converted.loadPath);
+    if ((converted.serverAddPath || converted.serverAddPaths) && shouldUseServerPath(converted.addPath, converted._detectedAddPath)) converted.addPath = getServerPath(converted.serverAddPaths, converted.serverAddPath);
+    else if (converted.addPath) converted.addPath = convertPath(converted.addPath);
+    delete converted.serverLoadPath;
+    delete converted.serverAddPath;
+    delete converted.serverLoadPaths;
+    delete converted.serverAddPaths;
+    delete converted._detectedLoadPath;
+    delete converted._detectedAddPath;
     return converted;
 }
 export { DEFAULT_I18NEXT_BACKEND_OPTIONS, convertBackendOptions };

package/dist/types/cli/locales.d.ts

@@ -0,0 +1,17 @@
+import type { BackendOptions } from '../shared/type';
+interface NormalizedConfigForLocales {
+    server?: {
+        publicDir?: string | string[];
+    };
+}
+export interface DetectedLocalesDirectory {
+    loadPath: string;
+    addPath: string;
+    serverLoadPath: string;
+    serverAddPath: string;
+    serverLoadPaths?: string[];
+    serverAddPaths?: string[];
+}
+export declare function detectLocalesDirectory(appDirectory: string, normalizedConfig?: NormalizedConfigForLocales): DetectedLocalesDirectory | undefined;
+export declare function applyDetectedBackendPaths(backendOptions: BackendOptions, detectedLocales: DetectedLocalesDirectory | undefined): BackendOptions;
+export {};

package/dist/types/runtime/i18n/backend/defaults.d.ts

@@ -2,12 +2,15 @@ export declare const DEFAULT_I18NEXT_BACKEND_OPTIONS: {
     loadPath: string;
     addPath: string;
 };
-declare global {
-    interface Window {
-        __assetPrefix__?: string;
-    }
-}
-export declare function convertBackendOptions<T extends {
+interface InternalBackendPathOptions {
     loadPath?: string;
     addPath?: string;
-}>(options: T): T;
+    serverLoadPath?: string;
+    serverAddPath?: string;
+    serverLoadPaths?: string[];
+    serverAddPaths?: string[];
+    _detectedLoadPath?: string;
+    _detectedAddPath?: string;
+}
+export declare function convertBackendOptions<T extends InternalBackendPathOptions>(options: T): T;
+export {};

package/dist/types/runtime/i18n/backend/defaults.node.d.ts

@@ -2,7 +2,15 @@ export declare const DEFAULT_I18NEXT_BACKEND_OPTIONS: {
     loadPath: string;
     addPath: string;
 };
-export declare function convertBackendOptions<T extends {
+interface InternalBackendPathOptions {
     loadPath?: string;
     addPath?: string;
-}>(options: T): T;
+    serverLoadPath?: string;
+    serverAddPath?: string;
+    serverLoadPaths?: string[];
+    serverAddPaths?: string[];
+    _detectedLoadPath?: string;
+    _detectedAddPath?: string;
+}
+export declare function convertBackendOptions<T extends InternalBackendPathOptions>(options: T): T;
+export {};

package/dist/types/shared/type.d.ts

@@ -58,6 +58,26 @@ export interface BaseBackendOptions {
     enabled?: boolean;
     loadPath?: string;
     addPath?: string;
+    /**
+     * Internal file-system path used by the Node.js FS backend.
+     * Browser HTTP backend keeps using `loadPath`.
+     */
+    serverLoadPath?: string;
+    /**
+     * Internal file-system path candidates used by the Node.js FS backend.
+     * The first existing path under current cwd will be used.
+     */
+    serverLoadPaths?: string[];
+    /**
+     * Internal file-system path used by the Node.js FS backend.
+     * Browser HTTP backend keeps using `addPath`.
+     */
+    serverAddPath?: string;
+    /**
+     * Internal file-system path candidates used by the Node.js FS backend.
+     * The first existing path under current cwd will be used.
+     */
+    serverAddPaths?: string[];
     /**
      * Cache hit mode for chained backend (only effective when both `loadPath` and `sdk` are provided)
      *

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.3.0",
+  "version": "3.5.0",
   "engines": {
     "node": ">=20"
   },
@@ -85,19 +85,19 @@
     "i18next-fs-backend": "^2.6.3",
     "i18next-http-backend": "^3.0.6",
     "i18next-http-middleware": "^3.9.7",
-    "@modern-js/plugin": "3.3.0",
-    "@modern-js/runtime-utils": "3.3.0",
-    "@modern-js/server-core": "3.3.0",
-    "@modern-js/server-runtime": "3.3.0",
-    "@modern-js/types": "3.3.0",
-    "@modern-js/utils": "3.3.0"
+    "@modern-js/plugin": "3.5.0",
+    "@modern-js/runtime-utils": "3.5.0",
+    "@modern-js/server-core": "3.5.0",
+    "@modern-js/server-runtime": "3.5.0",
+    "@modern-js/types": "3.5.0",
+    "@modern-js/utils": "3.5.0"
   },
   "peerDependencies": {
     "react": ">=17.0.2",
     "react-dom": ">=17.0.2",
     "i18next": ">=25.7.4",
     "react-i18next": ">=15.7.4",
-    "@modern-js/runtime": "^3.3.0"
+    "@modern-js/runtime": "^3.5.0"
   },
   "peerDependenciesMeta": {
     "i18next": {
@@ -108,7 +108,7 @@
     }
   },
   "devDependencies": {
-    "@rslib/core": "0.22.0",
+    "@rslib/core": "0.23.0",
     "@types/node": "^20",
     "i18next": "25.7.4",
     "react": "^19.2.7",
@@ -116,9 +116,9 @@
     "react-i18next": "15.7.4",
     "ts-node": "^10.9.2",
     "typescript": "^5",
+    "@modern-js/app-tools": "3.5.0",
     "@modern-js/rslib": "2.68.10",
-    "@modern-js/app-tools": "3.3.0",
-    "@modern-js/runtime": "3.3.0"
+    "@modern-js/runtime": "3.5.0"
   },
   "sideEffects": false,
   "publishConfig": {

package/src/cli/index.ts

@@ -1,10 +1,9 @@
-import fs from 'fs';
-import path from 'path';
 import type { AppTools, CliPlugin } from '@modern-js/app-tools';
 import { getPublicDirRoutePrefixes } from '@modern-js/server-core';
 import type { Entrypoint } from '@modern-js/types';
 import type { BackendOptions, LocaleDetectionOptions } from '../shared/type';
 import { getBackendOptions, getLocaleDetectionOptions } from '../shared/utils';
+import { applyDetectedBackendPaths, detectLocalesDirectory } from './locales';
 import '../runtime/types';
 
 export type TransformRuntimeConfigFn = (
@@ -12,75 +11,6 @@ export type TransformRuntimeConfigFn = (
   entrypoint: Entrypoint,
 ) => Record<string, any>;
 
-/**
- * Check if a directory exists and contains JSON files
- */
-function hasJsonFiles(dirPath: string): boolean {
-  try {
-    if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory()) {
-      return false;
-    }
-    const entries = fs.readdirSync(dirPath);
-    // Check if there are any JSON files in the directory or subdirectories
-    for (const entry of entries) {
-      const entryPath = path.join(dirPath, entry);
-      const stat = fs.statSync(entryPath);
-      if (stat.isFile() && entry.endsWith('.json')) {
-        return true;
-      }
-      if (stat.isDirectory()) {
-        // Recursively check subdirectories (e.g., locales/en/, locales/zh/)
-        if (hasJsonFiles(entryPath)) {
-          return true;
-        }
-      }
-    }
-    return false;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Auto-detect if locales directory exists with JSON files
- * Checks both project root and config/public directory
- */
-function detectLocalesDirectory(
-  appDirectory: string,
-  normalizedConfig?: any,
-): boolean {
-  // Check project root directory
-  const rootLocalesPath = path.join(appDirectory, 'locales');
-  if (hasJsonFiles(rootLocalesPath)) {
-    return true;
-  }
-
-  // Check config/public directory
-  const configPublicPath = path.join(
-    appDirectory,
-    'config',
-    'public',
-    'locales',
-  );
-  if (hasJsonFiles(configPublicPath)) {
-    return true;
-  }
-
-  // Check publicDir if configured
-  const publicDir = normalizedConfig?.server?.publicDir;
-  if (publicDir) {
-    const publicDirPath = Array.isArray(publicDir) ? publicDir[0] : publicDir;
-    const localesPath = path.isAbsolute(publicDirPath)
-      ? path.join(publicDirPath, 'locales')
-      : path.join(appDirectory, publicDirPath, 'locales');
-    if (hasJsonFiles(localesPath)) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
 export interface I18nPluginOptions {
   localeDetection?: LocaleDetectionOptions;
   backend?: BackendOptions;
@@ -118,10 +48,14 @@ export const i18nPlugin = (
       // Auto-detect locales directory and enable backend if:
       // 1. User didn't explicitly set backend.enabled to false
       // 2. Locales directory exists with JSON files
-      // 3. If user configured loadPath or addPath, auto-enable backend without detection
+      // 3. If user configured loadPath or addPath, auto-enable backend
       let backendOptions: BackendOptions | undefined;
       const { appDirectory } = api.getAppContext();
       const normalizedConfig = api.getNormalizedConfig();
+      const detectedLocales = detectLocalesDirectory(
+        appDirectory,
+        normalizedConfig,
+      );
 
       if (backend) {
         const entryBackendOptions = getBackendOptions(
@@ -132,45 +66,35 @@ export const i18nPlugin = (
         if (entryBackendOptions?.enabled === false) {
           backendOptions = entryBackendOptions;
         } else {
-          // If user configured loadPath or addPath, auto-enable backend
-          // No need to detect locales directory since user has specified the path
-          if (entryBackendOptions?.loadPath || entryBackendOptions?.addPath) {
+          if (detectedLocales) {
+            backendOptions = applyDetectedBackendPaths(
+              entryBackendOptions,
+              detectedLocales,
+            );
+          } else if (
+            entryBackendOptions?.loadPath ||
+            entryBackendOptions?.addPath
+          ) {
+            // If user configured loadPath or addPath, auto-enable backend even
+            // when no local locales directory is detected.
             backendOptions = {
               ...entryBackendOptions,
               enabled: true,
             };
-          } else if (entryBackendOptions?.enabled !== true) {
-            // Auto-detect if enabled is not explicitly true and no loadPath/addPath configured
-            const hasLocales = detectLocalesDirectory(
-              appDirectory,
-              normalizedConfig,
-            );
-
-            if (hasLocales) {
-              // Auto-enable backend if locales directory is detected
-              backendOptions = {
-                ...entryBackendOptions,
-                enabled: true,
-              };
-            } else {
-              backendOptions = entryBackendOptions;
-            }
           } else {
             backendOptions = entryBackendOptions;
           }
         }
       } else {
         // No backend config provided, try auto-detection
-        const hasLocales = detectLocalesDirectory(
-          appDirectory,
-          normalizedConfig,
-        );
-
-        if (hasLocales) {
+        if (detectedLocales) {
           // Auto-enable backend if locales directory is detected
-          backendOptions = getBackendOptions(entrypoint.entryName, {
-            enabled: true,
-          });
+          backendOptions = applyDetectedBackendPaths(
+            getBackendOptions(entrypoint.entryName, {
+              enabled: true,
+            }),
+            detectedLocales,
+          );
         }
       }
 

package/src/cli/locales.ts

@@ -0,0 +1,186 @@
+import fs from 'fs';
+import path from 'path';
+import {
+  getPublicDirRoutePrefixes,
+  normalizePublicDir,
+  normalizePublicDirPath,
+} from '@modern-js/server-core';
+import type { BackendOptions } from '../shared/type';
+
+interface NormalizedConfigForLocales {
+  server?: {
+    publicDir?: string | string[];
+  };
+}
+
+export interface DetectedLocalesDirectory {
+  loadPath: string;
+  addPath: string;
+  serverLoadPath: string;
+  serverAddPath: string;
+  serverLoadPaths?: string[];
+  serverAddPaths?: string[];
+}
+
+const LOCALES_RESOURCE_PATTERN = '{{lng}}/{{ns}}.json';
+
+function hasJsonFiles(dirPath: string): boolean {
+  try {
+    if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory()) {
+      return false;
+    }
+    const entries = fs.readdirSync(dirPath);
+    for (const entry of entries) {
+      const entryPath = path.join(dirPath, entry);
+      const stat = fs.statSync(entryPath);
+      if (stat.isFile() && entry.endsWith('.json')) {
+        return true;
+      }
+      if (stat.isDirectory() && hasJsonFiles(entryPath)) {
+        return true;
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+function toPosixPath(filePath: string): string {
+  return filePath.split(path.sep).join(path.posix.sep);
+}
+
+function getPublicDirOutputPath(publicDir: string): string {
+  return normalizePublicDirPath(publicDir);
+}
+
+function buildDetectedLocalesDirectory(
+  clientBasePath: string,
+  serverBasePath: string,
+  serverBasePathCandidates: string[] = [serverBasePath],
+): DetectedLocalesDirectory {
+  const normalizedClientBasePath = clientBasePath.startsWith('/')
+    ? clientBasePath
+    : `/${clientBasePath}`;
+  const normalizedServerBasePath = toPosixPath(serverBasePath).replace(
+    /\/$/,
+    '',
+  );
+  const normalizedServerBasePathCandidates = Array.from(
+    new Set(
+      serverBasePathCandidates.map(candidate =>
+        toPosixPath(candidate).replace(/\/$/, ''),
+      ),
+    ),
+  );
+  const serverLoadPaths = normalizedServerBasePathCandidates.map(
+    candidate => `${candidate}/${LOCALES_RESOURCE_PATTERN}`,
+  );
+  const serverAddPaths = normalizedServerBasePathCandidates.map(
+    candidate => `${candidate}/${LOCALES_RESOURCE_PATTERN}`,
+  );
+
+  return {
+    loadPath: `${normalizedClientBasePath}/${LOCALES_RESOURCE_PATTERN}`,
+    addPath: `${normalizedClientBasePath}/${LOCALES_RESOURCE_PATTERN}`,
+    serverLoadPath: `${normalizedServerBasePath}/${LOCALES_RESOURCE_PATTERN}`,
+    serverAddPath: `${normalizedServerBasePath}/${LOCALES_RESOURCE_PATTERN}`,
+    serverLoadPaths,
+    serverAddPaths,
+  };
+}
+
+export function detectLocalesDirectory(
+  appDirectory: string,
+  normalizedConfig?: NormalizedConfigForLocales,
+): DetectedLocalesDirectory | undefined {
+  const publicDirs = normalizePublicDir(normalizedConfig?.server?.publicDir);
+  const publicDirPrefixes = getPublicDirRoutePrefixes(
+    normalizedConfig?.server?.publicDir,
+  );
+
+  for (let index = 0; index < publicDirs.length; index++) {
+    const publicDir = publicDirs[index];
+    if (path.isAbsolute(publicDir)) {
+      continue;
+    }
+
+    const publicDirPath = path.join(appDirectory, publicDir);
+    const publicDirPrefix =
+      publicDirPrefixes[index] || `/${normalizePublicDirPath(publicDir)}`;
+    const publicDirOutputPath = getPublicDirOutputPath(publicDir);
+
+    if (
+      path.basename(normalizePublicDirPath(publicDir)) === 'locales' &&
+      hasJsonFiles(publicDirPath)
+    ) {
+      return buildDetectedLocalesDirectory(
+        publicDirPrefix,
+        `./${publicDirOutputPath}`,
+      );
+    }
+
+    const localesPath = path.join(publicDirPath, 'locales');
+    if (hasJsonFiles(localesPath)) {
+      return buildDetectedLocalesDirectory(
+        `${publicDirPrefix}/locales`,
+        `./${publicDirOutputPath}/locales`,
+      );
+    }
+  }
+
+  const configPublicPath = path.join(
+    appDirectory,
+    'config',
+    'public',
+    'locales',
+  );
+  if (hasJsonFiles(configPublicPath)) {
+    return buildDetectedLocalesDirectory('/locales', './public/locales', [
+      './config/public/locales',
+      './public/locales',
+    ]);
+  }
+
+  const rootLocalesPath = path.join(appDirectory, 'locales');
+  if (hasJsonFiles(rootLocalesPath)) {
+    return buildDetectedLocalesDirectory('/locales', './locales');
+  }
+
+  return undefined;
+}
+
+export function applyDetectedBackendPaths(
+  backendOptions: BackendOptions,
+  detectedLocales: DetectedLocalesDirectory | undefined,
+): BackendOptions {
+  if (!detectedLocales) {
+    return backendOptions;
+  }
+
+  const backendWithDetectedPaths: BackendOptions & {
+    _detectedLoadPath: string;
+    _detectedAddPath: string;
+  } = {
+    ...backendOptions,
+    enabled: true,
+    loadPath: backendOptions.loadPath ?? detectedLocales.loadPath,
+    addPath: backendOptions.addPath ?? detectedLocales.addPath,
+    serverLoadPath:
+      backendOptions.serverLoadPath ?? detectedLocales.serverLoadPath,
+    serverLoadPaths:
+      backendOptions.serverLoadPath || backendOptions.serverLoadPaths
+        ? backendOptions.serverLoadPaths
+        : detectedLocales.serverLoadPaths,
+    serverAddPath:
+      backendOptions.serverAddPath ?? detectedLocales.serverAddPath,
+    serverAddPaths:
+      backendOptions.serverAddPath || backendOptions.serverAddPaths
+        ? backendOptions.serverAddPaths
+        : detectedLocales.serverAddPaths,
+    _detectedLoadPath: detectedLocales.loadPath,
+    _detectedAddPath: detectedLocales.addPath,
+  };
+
+  return backendWithDetectedPaths;
+}