@bleedingdev/modern-js-plugin-i18n 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/src/server/mappedUrlStrategy.ts

@@ -0,0 +1,10 @@
+/**
+ * The mapped-URL policy moved to `../shared` so the client runtime can derive
+ * the same policy the server does — SSR and a hydrated `<Link>` have to agree
+ * on the mapping or client navigation targets a path the server will not serve.
+ * Re-exported here to keep the server-side import path stable.
+ */
+export {
+  createMappedUrlStrategy,
+  resolveMappedUrlStrategy,
+} from '../shared/mappedUrlStrategy';

package/src/server/redirectPolicy.ts

@@ -1,76 +1,91 @@
-import {
-  isDefaultLocaleRedirectSkipPath,
-  localiseTargetPathname,
-  matchesPathPrefix,
-  shouldSkipLocaleRedirect,
-  stripLanguagePrefix,
-} from '@modern-js/i18n-runtime-extensions';
-import type { LocaleDetectionOptions } from '../shared/type';
+import { isDefaultLocaleRedirectSkipPath } from '../shared/mappedUrlStrategy';
+import { asI18nUrlStrategy, type I18nUrlStrategy } from '../shared/urlStrategy';
 
 interface LocaleRedirectRequest {
   url: string;
-  header: () => {
-    host?: string;
-  };
+  header?: () => { host?: string };
 }
 
 const stripUrlPathPrefix = (pathname: string, urlPath: string): string => {
   const basePath = urlPath.replace('/*', '');
-
   if (!basePath || basePath === '/') {
     return pathname;
   }
-
-  const remainingPath = pathname.startsWith(basePath)
-    ? pathname.slice(basePath.length)
+  return pathname === basePath || pathname.startsWith(`${basePath}/`)
+    ? pathname.slice(basePath.length) || '/'
     : pathname;
-
-  return remainingPath || '/';
 };
 
-/**
- * Check if pathname should ignore automatic locale redirect.
- */
 export const shouldIgnoreRedirect = (
   pathname: string,
   urlPath: string,
   ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean),
+  urlStrategy?: I18nUrlStrategy,
+  languages: string[] = [],
 ): boolean => {
   const remainingPath = stripUrlPathPrefix(pathname, urlPath);
-
-  return shouldSkipLocaleRedirect(remainingPath, [], ignoreRedirectRoutes);
+  // Federation artifacts (`backend-mf-manifest.json`, `backendRemoteEntry.cjs`,
+  // `mf-manifest.json`, …) are never pages: redirecting them to a locale
+  // prefix hands a remote consumer an HTML document. This is native policy and
+  // does not depend on a URL strategy being configured; a strategy can only
+  // add exclusions.
+  if (isDefaultLocaleRedirectSkipPath(remainingPath, languages)) {
+    return true;
+  }
+  if (
+    asI18nUrlStrategy(urlStrategy)?.shouldSkipRedirect?.(
+      remainingPath,
+      languages,
+    )
+  ) {
+    return true;
+  }
+  if (!ignoreRedirectRoutes) {
+    return false;
+  }
+  const segments = remainingPath.split('/').filter(Boolean);
+  if (
+    segments[0] &&
+    languages.some(
+      language => language.toLowerCase() === segments[0].toLowerCase(),
+    )
+  ) {
+    segments.shift();
+  }
+  const normalizedPath = `/${segments.join('/')}`;
+  return typeof ignoreRedirectRoutes === 'function'
+    ? ignoreRedirectRoutes(normalizedPath)
+    : ignoreRedirectRoutes.some(
+        pattern =>
+          normalizedPath === pattern ||
+          normalizedPath.startsWith(`${pattern}/`),
+      );
 };
 
-/**
- * Check if pathname is a static or federation resource request.
- *
- * This includes configured staticRoutePrefixes, the shared default skip policy
- * from ADR-0002, and language-prefixed variants such as /en/static/app.js.
- */
+/** Native configured/static exclusions remain in effect for every strategy. */
 export const isStaticResourceRequest = (
   pathname: string,
   staticRoutePrefixes: string[],
   languages: string[] = [],
 ): boolean => {
-  if (isDefaultLocaleRedirectSkipPath(pathname, languages)) {
-    return true;
-  }
-
-  const matchesStaticRoutePrefix = (targetPathname: string): boolean =>
-    staticRoutePrefixes.some(prefix =>
-      matchesPathPrefix(targetPathname, prefix),
+  const prefixes = [...staticRoutePrefixes, '/static', '/upload'];
+  const matches = (target: string) =>
+    prefixes.some(
+      prefix => target === prefix || target.startsWith(`${prefix}/`),
     );
-
-  if (matchesStaticRoutePrefix(pathname)) {
+  if (matches(pathname)) {
     return true;
   }
-
-  const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
-
-  return (
-    pathWithoutLanguage !== pathname &&
-    matchesStaticRoutePrefix(pathWithoutLanguage)
-  );
+  const segments = pathname.split('/').filter(Boolean);
+  if (
+    segments[0] &&
+    languages.some(
+      language => language.toLowerCase() === segments[0].toLowerCase(),
+    )
+  ) {
+    return matches(`/${segments.slice(1).join('/')}`);
+  }
+  return false;
 };
 
 export const getLanguageFromPath = (
@@ -78,17 +93,16 @@ export const getLanguageFromPath = (
   urlPath: string,
   languages: string[],
 ): string | null => {
-  const url = new URL(req.url, `http://${req.header().host}`);
-  const pathname = url.pathname;
-  const remainingPath = stripUrlPathPrefix(pathname, urlPath);
-  const segments = remainingPath.split('/').filter(Boolean);
-  const firstSegment = segments[0];
-
-  if (languages.includes(firstSegment)) {
-    return firstSegment;
-  }
-
-  return null;
+  const host = req.header?.().host;
+  const url = new URL(req.url, host ? `http://${host}` : undefined);
+  const firstSegment = stripUrlPathPrefix(url.pathname, urlPath)
+    .split('/')
+    .filter(Boolean)[0];
+  return (
+    languages.find(
+      language => language.toLowerCase() === firstSegment?.toLowerCase(),
+    ) ?? null
+  );
 };
 
 export const buildLocalizedUrl = (
@@ -96,24 +110,25 @@ export const buildLocalizedUrl = (
   urlPath: string,
   language: string,
   languages: string[],
-  localisedUrls?: LocaleDetectionOptions['localisedUrls'],
+  urlStrategy?: I18nUrlStrategy,
 ): string => {
   const url = new URL(req.url);
-  const pathname = url.pathname;
   const basePath = urlPath.replace('/*', '');
-  const remainingPath = stripUrlPathPrefix(pathname, urlPath);
-
-  const newPathname = localiseTargetPathname(
-    remainingPath,
-    language,
-    languages,
-    localisedUrls,
-  );
-  const suffix = `${url.search}${url.hash}`;
-  const localizedUrl =
-    basePath === '/' ? newPathname + suffix : basePath + newPathname + suffix;
-
-  return localizedUrl;
+  const remainingPath = stripUrlPathPrefix(url.pathname, urlPath);
+  const segments = remainingPath.split('/').filter(Boolean);
+  if (
+    segments[0] &&
+    languages.some(item => item.toLowerCase() === segments[0].toLowerCase())
+  ) {
+    segments[0] = language;
+  } else {
+    segments.unshift(language);
+  }
+  const strategy = asI18nUrlStrategy(urlStrategy);
+  const pathname = strategy
+    ? strategy.localizePathname(remainingPath, language, languages)
+    : `/${segments.join('/')}`;
+  return `${basePath === '/' ? '' : basePath}${pathname}${url.search}${url.hash}`;
 };
 
 export const createLocaleRedirectResponse = (location: string): Response =>

package/src/shared/mappedUrlStrategy.ts

@@ -0,0 +1,59 @@
+import {
+  canonicalTargetPathname,
+  isDefaultLocaleRedirectSkipPath,
+  type LocalisedUrlsOption,
+  localiseTargetPathname,
+} from '@modern-js/i18n-runtime-extensions';
+import type { I18nUrlStrategy } from './urlStrategy';
+
+/**
+ * The fork's native locale-redirect exclusions (federation artifacts, static
+ * and upload prefixes). Re-exported from this fork-owned seam so the native
+ * runtime and server redirect paths apply them without importing the
+ * extensions package themselves.
+ */
+export { isDefaultLocaleRedirectSkipPath } from '@modern-js/i18n-runtime-extensions';
+
+/**
+ * Build the URL policy from a mapped-locale-URL configuration.
+ *
+ * `localeDetection.localisedUrls` is plain data, so unlike a `urlStrategy`
+ * object it survives the JSON boundary between `modern.config.ts` and the
+ * generated runtime registration. It is therefore the one configuration both
+ * sides can rely on for mapped URLs.
+ *
+ * This is shared rather than server-only on purpose. The server and the client
+ * have to agree on the mapping or a hydrated `<Link>` navigates to a path the
+ * server will not serve: SSR renders `/cs/obchodni-podminky` while a
+ * client-side navigation asks for `/cs/terms-of-service`. The helpers below are
+ * pure pathname functions from `@modern-js/i18n-runtime-extensions`, so the
+ * client cost is a few hundred bytes of string work and no i18n engine.
+ */
+export const createMappedUrlStrategy = (
+  localisedUrls?: LocalisedUrlsOption,
+): I18nUrlStrategy => ({
+  localizePathname: (pathname, language, languages) =>
+    localiseTargetPathname(pathname, language, [...languages], localisedUrls),
+  canonicalPathname: (pathname, languages) =>
+    canonicalTargetPathname(pathname, [...languages], localisedUrls),
+  shouldSkipRedirect: (pathname, languages) =>
+    isDefaultLocaleRedirectSkipPath(pathname, [...languages]),
+});
+
+/** Only a non-empty map needs a derived policy. */
+export const resolveMappedUrlStrategy = (
+  localeDetection: unknown,
+): I18nUrlStrategy | undefined => {
+  if (!localeDetection || typeof localeDetection !== 'object') {
+    return undefined;
+  }
+  const localisedUrls = Reflect.get(localeDetection, 'localisedUrls');
+  if (
+    !localisedUrls ||
+    typeof localisedUrls !== 'object' ||
+    Object.keys(localisedUrls).length === 0
+  ) {
+    return undefined;
+  }
+  return createMappedUrlStrategy(localisedUrls as LocalisedUrlsOption);
+};

package/src/shared/type.ts

@@ -1,4 +1,3 @@
-import type { LocalisedUrlsOption } from '@modern-js/i18n-runtime-extensions';
 import type {
   LanguageDetectorOptions,
   Resources,
@@ -12,18 +11,15 @@ export interface BaseLocaleDetectionOptions {
   detection?: LanguageDetectorOptions;
   ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean);
   /**
-   * Enables localised pathnames in addition to the locale prefix.
+   * Canonical-path -> per-language path map, e.g.
+   * `{ '/products': { en: '/products', cs: '/produkty' } }`.
    *
-   * - non-empty object: map canonical route paths to every configured
-   *   language; route generation then validates that every localisable route
-   *   path has entries for all configured languages.
-   * - absent / `false` / `true` / empty object: keep only locale-prefix
-   *   behavior (`/en/about`).
-   *
-   * Strictly opt-in: without a map, `localePathRedirect` + `languages` behave
-   * exactly like upstream Modern.js.
+   * Plain data on purpose: the generated runtime registration carries plugin
+   * options as JSON, so a map survives the trip where a `urlStrategy` object
+   * would lose its methods. The CLI expands file-system routes from it, and
+   * the server derives its URL strategy from it, with no extra plugin.
    */
-  localisedUrls?: LocalisedUrlsOption;
+  localisedUrls?: boolean | Record<string, Record<string, string>>;
 }
 
 export interface LocaleDetectionOptions extends BaseLocaleDetectionOptions {

package/src/shared/urlStrategy.ts

@@ -0,0 +1,38 @@
+/** Per-plugin URL policy. Search and hash remain owned by native URL handling. */
+export interface I18nUrlStrategy {
+  localizePathname(
+    pathname: string,
+    language: string,
+    languages: readonly string[],
+  ): string;
+  canonicalPathname(pathname: string, languages: readonly string[]): string;
+  /** Adds exclusions; it cannot enable redirects excluded by native rules. */
+  shouldSkipRedirect?(pathname: string, languages: readonly string[]): boolean;
+}
+
+/**
+ * A URL strategy reaches the runtime through the generated runtime
+ * registration, which carries plugin options as JSON. Functions do not survive
+ * that, so a configured strategy can arrive as an empty object — which is
+ * truthy and would make every call site throw. Anything that is not a complete
+ * strategy is treated as absent, and the caller falls back to the built-in
+ * language-prefix behaviour.
+ */
+export const asI18nUrlStrategy = (
+  candidate: unknown,
+): I18nUrlStrategy | undefined => {
+  if (!candidate || typeof candidate !== 'object') {
+    return undefined;
+  }
+  const strategy = candidate as Partial<I18nUrlStrategy>;
+  return typeof strategy.localizePathname === 'function' &&
+    typeof strategy.canonicalPathname === 'function'
+    ? (strategy as I18nUrlStrategy)
+    : undefined;
+};
+
+/** `true` when a value was configured as a strategy but cannot be used as one. */
+export const isUnusableI18nUrlStrategy = (candidate: unknown): boolean =>
+  Boolean(candidate) &&
+  typeof candidate === 'object' &&
+  asI18nUrlStrategy(candidate) === undefined;

package/tests/backendDefaults.test.ts

@@ -1,11 +1,8 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { afterEach, describe, expect, test } from '@rstest/core';
-import {
-  DEFAULT_I18NEXT_BACKEND_OPTIONS,
-  resolveDefaultLocalesDir,
-} from '../src/runtime/i18n/backend/defaults.node';
+import { describe, expect, test } from '@rstest/core';
+import { resolveDefaultLocalesDir } from '../src/runtime/i18n/backend/defaults.node';
 
 const makeTempDir = (...dirs: string[]): string => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'i18n-defaults-'));
@@ -16,12 +13,6 @@ const makeTempDir = (...dirs: string[]): string => {
 };
 
 describe('node backend default loadPath', () => {
-  const originalCwd = process.cwd();
-
-  afterEach(() => {
-    process.chdir(originalCwd);
-  });
-
   test('prefers the project-root ./locales convention (the detection root)', () => {
     const root = makeTempDir('locales', 'config/public/locales');
     expect(resolveDefaultLocalesDir(root)).toBe('./locales');
@@ -36,16 +27,4 @@ describe('node backend default loadPath', () => {
     const root = makeTempDir();
     expect(resolveDefaultLocalesDir(root)).toBe('./locales');
   });
-
-  test('DEFAULT_I18NEXT_BACKEND_OPTIONS resolves against the working directory', () => {
-    const root = makeTempDir('locales');
-    process.chdir(root);
-
-    expect(DEFAULT_I18NEXT_BACKEND_OPTIONS.loadPath).toBe(
-      './locales/{{lng}}/{{ns}}.json',
-    );
-    expect(DEFAULT_I18NEXT_BACKEND_OPTIONS.addPath).toBe(
-      './locales/{{lng}}/{{ns}}.json',
-    );
-  });
 });

package/tests/defaultUrlStrategy.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, test } from '@rstest/core';
+import { i18nServerPlugin } from '../src/server';
+import { resolveDefaultUrlStrategy } from '../src/server/defaultUrlStrategy';
+
+const localisedUrls = {
+  '/about': { en: '/about', cs: '/o-nas' },
+};
+
+const createRequestContext = (pathname: string) =>
+  ({
+    req: { url: `http://localhost${pathname}` },
+  }) as any;
+
+const bootServerPlugin = (options: Parameters<typeof i18nServerPlugin>[0]) => {
+  const middlewares: any[] = [];
+  const routes = [{ entryName: 'main', entryPath: '', urlPath: '/' }];
+  let prepare: (() => void) | undefined;
+
+  i18nServerPlugin(options).setup({
+    getServerConfig: () => ({}),
+    getServerContext: () => ({ middlewares, routes }),
+    onPrepare: (fn: () => void) => {
+      prepare = fn;
+    },
+  } as any);
+
+  prepare?.();
+  return middlewares;
+};
+
+describe('default URL strategy', () => {
+  test('a mapped locale URL config alone produces a strategy', () => {
+    const strategy = resolveDefaultUrlStrategy(localisedUrls);
+
+    expect(strategy).toBeDefined();
+    expect(strategy?.localizePathname('/about', 'cs', ['en', 'cs'])).toBe(
+      '/cs/o-nas',
+    );
+    expect(strategy?.canonicalPathname('/cs/o-nas', ['en', 'cs'])).toBe(
+      '/about',
+    );
+  });
+
+  test('no map means no derived strategy', () => {
+    expect(resolveDefaultUrlStrategy(undefined)).toBeUndefined();
+    expect(resolveDefaultUrlStrategy({})).toBeUndefined();
+    expect(resolveDefaultUrlStrategy('nope')).toBeUndefined();
+  });
+
+  test('`localisedUrls` boots the server without any extra plugin', () => {
+    // Previously this threw "Mapped locale URLs require a URL strategy",
+    // which stopped every existing consumer's server from starting.
+    const middlewares = bootServerPlugin({
+      localeDetection: {
+        fallbackLanguage: 'en',
+        languages: ['en', 'cs'],
+        localePathRedirect: true,
+        localisedUrls,
+      } as any,
+      staticRoutePrefixes: [],
+    });
+
+    expect(middlewares.map(middleware => middleware.name)).toContain(
+      'i18n-server-middleware',
+    );
+  });
+
+  test('redirects a canonical path to its mapped locale URL', async () => {
+    const middlewares = bootServerPlugin({
+      localeDetection: {
+        fallbackLanguage: 'en',
+        languages: ['en', 'cs'],
+        localePathRedirect: true,
+        localisedUrls,
+      } as any,
+      staticRoutePrefixes: [],
+    });
+
+    const redirect = middlewares.find(
+      middleware => middleware.name === 'i18n-server-middleware',
+    );
+    const context = createRequestContext('/about');
+    context.get = () => 'cs';
+    const response = await redirect.handler(context, async () => undefined);
+
+    expect(response?.headers?.get('location')).toBe('/cs/o-nas');
+  });
+
+  test('an explicit strategy still wins over the derived one', () => {
+    const explicit = {
+      localizePathname: () => '/explicit',
+      canonicalPathname: () => '/explicit',
+    };
+    const middlewares = bootServerPlugin({
+      localeDetection: {
+        fallbackLanguage: 'en',
+        languages: ['en', 'cs'],
+        localePathRedirect: true,
+        localisedUrls,
+      } as any,
+      staticRoutePrefixes: [],
+      resolveUrlStrategy: () => explicit,
+    });
+
+    expect(middlewares.length).toBeGreaterThan(0);
+  });
+});

package/tests/federatedI18nBoundaryResolver.test.tsx

@@ -0,0 +1,65 @@
+import { RuntimeComponentResolverContext } from '@modern-js/runtime/context';
+import { describe, expect, test } from '@rstest/core';
+import { useState } from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
+import {
+  FederatedI18nBoundary,
+  type FederatedI18nBoundaryProps,
+} from '../src/runtime/context';
+
+const props: FederatedI18nBoundaryProps = {
+  defaultNamespace: 'inventory',
+  resources: {},
+  children: <span>child content</span>,
+};
+
+describe('native federation resolver wrapper', () => {
+  test('retains the actionable fallback when a resolver does not handle i18n', () => {
+    expect(() =>
+      renderToStaticMarkup(
+        <RuntimeComponentResolverContext.Provider
+          value={component => component}
+        >
+          <FederatedI18nBoundary {...props} />
+        </RuntimeComponentResolverContext.Provider>,
+      ),
+    ).toThrow(/requires the @modern-js\/i18n-integration runtime plugin/);
+  });
+
+  test('rejects resolution back to the native wrapper', () => {
+    expect(() =>
+      renderToStaticMarkup(
+        <RuntimeComponentResolverContext.Provider
+          value={() => FederatedI18nBoundary}
+        >
+          <FederatedI18nBoundary {...props} />
+        </RuntimeComponentResolverContext.Provider>,
+      ),
+    ).toThrow(/resolver returned its own wrapper/);
+  });
+
+  test('renders the resolved hook-bearing component with unchanged props', () => {
+    let receivedProps: FederatedI18nBoundaryProps | undefined;
+    function ResolvedBoundary(value: FederatedI18nBoundaryProps) {
+      receivedProps = value;
+      const [label] = useState('resolved');
+      return (
+        <section>
+          {label}:{value.children}
+        </section>
+      );
+    }
+    const html = renderToStaticMarkup(
+      <RuntimeComponentResolverContext.Provider
+        value={(component, { name }) =>
+          name === 'i18n.FederatedI18nBoundary' ? ResolvedBoundary : component
+        }
+      >
+        <FederatedI18nBoundary {...props} />
+      </RuntimeComponentResolverContext.Provider>,
+    );
+    expect(html).toBe('<section>resolved:<span>child content</span></section>');
+    expect(receivedProps?.resources).toBe(props.resources);
+    expect(receivedProps?.defaultNamespace).toBe('inventory');
+  });
+});

package/tests/i18nUtils.test.ts

@@ -1,28 +1,11 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import { describe, expect, test } from '@rstest/core';
-import type { I18nInstance } from '../src/runtime/i18n';
-import {
-  DEFAULT_I18NEXT_BACKEND_OPTIONS as NODE_DEFAULT_I18NEXT_BACKEND_OPTIONS,
-  resolveDefaultLocalesDir,
-} from '../src/runtime/i18n/backend/defaults.node';
 import {
   FsBackendWithSave,
   resolveFsBackendConstructor,
 } from '../src/runtime/i18n/backend/middleware.node';
-import { initializeI18nInstance } from '../src/runtime/i18n/utils';
-
-function createBackendI18nInstance(): I18nInstance {
-  return {
-    language: 'en',
-    isInitialized: false,
-    init: async () => undefined,
-    use: () => {},
-    t: (key: string | string[]) => (Array.isArray(key) ? key[0] : key),
-    options: {},
-    store: {
-      data: {},
-    },
-  };
-}
 
 describe('i18n runtime utils', () => {
   test('normalizes node fs backend CJS and ESM namespace shapes', () => {
@@ -45,50 +28,33 @@ describe('i18n runtime utils', () => {
     ).toBe(FakeBackend);
   });
 
-  test('node fs backend wrapper extends a resolved constructor', () => {
-    const backend = new FsBackendWithSave({}, {}, {}) as {
-      type?: string;
-      save: (language: string, namespace: string, data: unknown) => void;
-    };
-
-    expect(backend.type).toBe('backend');
-    expect(() => backend.save('en', 'translation', {})).not.toThrow();
-  });
-
-  test('node fs backend defaults follow the detected locales directory', () => {
-    // The default must match whichever conventional root exists at runtime
-    // (./locales first, then ./config/public/locales), mirroring the CLI
-    // plugin's detectLocalesDirectory. Detailed precedence cases live in
-    // tests/backendDefaults.test.ts.
-    expect(NODE_DEFAULT_I18NEXT_BACKEND_OPTIONS.loadPath).toBe(
-      `${resolveDefaultLocalesDir()}/{{lng}}/{{ns}}.json`,
-    );
-  });
-
-  test('does not poll for backend resources after init', async () => {
-    const i18nInstance = createBackendI18nInstance();
-    const init = rstest.fn(async () => {
-      i18nInstance.isInitialized = true;
-    });
-    i18nInstance.init = init as I18nInstance['init'];
-    const setTimeoutSpy = rstest.spyOn(globalThis, 'setTimeout');
-
-    await initializeI18nInstance(
-      i18nInstance,
-      'cs',
-      'en',
-      ['en', 'cs'],
-      {},
-      {
-        enabled: true,
-        loadPath: '/locales/{{lng}}/{{ns}}.json',
-      },
-      {},
-    );
-
-    expect(init).toHaveBeenCalledTimes(1);
-    expect(setTimeoutSpy).not.toHaveBeenCalled();
-
-    setTimeoutSpy.mockRestore();
+  test('loads translation resources through the node fs backend', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'i18n-backend-'));
+
+    try {
+      await mkdir(join(root, 'cs'), { recursive: true });
+      await writeFile(
+        join(root, 'cs', 'common.json'),
+        JSON.stringify({ title: 'Ahoj' }),
+      );
+      const backend = new FsBackendWithSave(
+        {},
+        { loadPath: join(root, '{{lng}}', '{{ns}}.json') },
+        {},
+      );
+      const resources = await new Promise<unknown>((resolve, reject) => {
+        backend.read('cs', 'common', (error: Error | null, data: unknown) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve(data);
+          }
+        });
+      });
+
+      expect(resources).toEqual({ title: 'Ahoj' });
+    } finally {
+      await rm(root, { force: true, recursive: true });
+    }
   });
 });