@bleedingdev/modern-js-plugin-i18n 3.2.0-ultramodern.99 → 3.4.0-ultramodern.0

package/tests/localisedUrls.test.ts

@@ -1,5 +1,6 @@
 import type { NestedRouteForCli } from '@modern-js/types';
 import { describe, expect, test } from '@rstest/core';
+import { i18nPlugin as i18nCliPlugin } from '../src/cli';
 import {
   collectApiPrefixes,
   i18nServerPlugin,
@@ -7,7 +8,12 @@ import {
 } from '../src/server';
 import {
   applyLocalisedUrlsToRoutes,
+  canonicalTargetPathname,
+  localiseTargetPathname,
+  matchPathPattern,
+  resolveCanonicalLocalisedPath,
   resolveLocalisedPath,
+  resolveLocalisedUrlsConfig,
   validateLocalisedUrls,
 } from '../src/shared/localisedUrls';
 
@@ -31,6 +37,74 @@ const createRequestContext = (pathname: string) =>
     },
   }) as any;
 
+describe('resolveLocalisedUrlsConfig', () => {
+  test('is opt-in: only a non-empty map enables the feature', () => {
+    const map = { '/about': { en: '/about', cs: '/o-nas' } };
+    expect(resolveLocalisedUrlsConfig(map)).toEqual({ enabled: true, map });
+  });
+
+  test('absent, boolean and empty-map options resolve to disabled', () => {
+    const disabled = { enabled: false, map: {} };
+    expect(resolveLocalisedUrlsConfig(undefined)).toEqual(disabled);
+    expect(resolveLocalisedUrlsConfig(false)).toEqual(disabled);
+    expect(resolveLocalisedUrlsConfig(true)).toEqual(disabled);
+    expect(resolveLocalisedUrlsConfig({})).toEqual(disabled);
+  });
+});
+
+describe('cli modifyFileSystemRoutes', () => {
+  const setupModifyRoutes = (localeDetection: Record<string, unknown>) => {
+    let modifyRoutes:
+      | ((args: { entrypoint: any; routes: any[] }) => {
+          entrypoint: any;
+          routes: any[];
+        })
+      | undefined;
+
+    i18nCliPlugin({ localeDetection }).setup({
+      _internalRuntimePlugins: () => {},
+      modifyFileSystemRoutes: (fn: any) => {
+        modifyRoutes = fn;
+      },
+      _internalServerPlugins: () => {},
+    } as any);
+
+    expect(modifyRoutes).toBeDefined();
+    return modifyRoutes!;
+  };
+
+  test('upstream-style configs without a map keep routes untouched', () => {
+    const modifyRoutes = setupModifyRoutes({
+      localePathRedirect: true,
+      languages: ['en', 'cs'],
+    });
+    const routes = [createRoute(':lang', [createRoute('about')])];
+
+    const result = modifyRoutes({ entrypoint: { entryName: 'main' }, routes });
+
+    expect(result.routes).toBe(routes);
+  });
+
+  test('a configured map still expands localised route aliases', () => {
+    const modifyRoutes = setupModifyRoutes({
+      localePathRedirect: true,
+      languages: ['en', 'cs'],
+      localisedUrls: {
+        '/about': { en: '/about', cs: '/o-nas' },
+      },
+    });
+    const routes = [createRoute(':lang', [createRoute('about')])];
+
+    const result = modifyRoutes({ entrypoint: { entryName: 'main' }, routes });
+
+    const localeRoute = result.routes[0] as NestedRouteForCli;
+    expect(localeRoute.children?.map(route => route.path)).toEqual([
+      'about',
+      'o-nas',
+    ]);
+  });
+});
+
 describe('localisedUrls', () => {
   test('requires every localisable route path to define every language', () => {
     const routes = [createRoute(':lang', [createRoute('terms-of-service')])];
@@ -163,6 +237,55 @@ describe('localisedUrls', () => {
     ).toBe('/products/cervena-bota');
   });
 
+  test('resolves static patterns before param patterns', () => {
+    const localisedUrls = {
+      '/products/:slug': {
+        en: '/products/:slug',
+        cs: '/produkty/:slug',
+      },
+      '/products/new': {
+        en: '/products/new',
+        cs: '/produkty/novinka',
+      },
+    };
+
+    expect(
+      resolveLocalisedPath('/products/new', 'cs', ['en', 'cs'], localisedUrls),
+    ).toBe('/produkty/novinka');
+    expect(
+      resolveCanonicalLocalisedPath(
+        '/produkty/novinka',
+        ['en', 'cs'],
+        localisedUrls,
+      ),
+    ).toBe('/products/new');
+  });
+
+  test('localises and canonicalises full target pathnames through one helper', () => {
+    const localisedUrls = {
+      '/products/:slug': {
+        en: '/products/:slug',
+        cs: '/produkty/:slug',
+      },
+    };
+
+    expect(
+      localiseTargetPathname(
+        '/en/products/cervena-bota',
+        'cs',
+        ['en', 'cs'],
+        localisedUrls,
+      ),
+    ).toBe('/cs/produkty/cervena-bota');
+    expect(
+      canonicalTargetPathname(
+        '/cs/produkty/cervena-bota',
+        ['en', 'cs'],
+        localisedUrls,
+      ),
+    ).toBe('/products/cervena-bota');
+  });
+
   test('resolves nested optional route params with translated ancestors', () => {
     const localisedUrls = {
       '/checkout': {
@@ -198,6 +321,47 @@ describe('localisedUrls', () => {
   });
 });
 
+describe('matchPathPattern decoding', () => {
+  test('decodes valid percent-encoded params', () => {
+    expect(
+      matchPathPattern('/produkty/%C4%8Derven%C3%A1', '/produkty/:slug'),
+    ).toEqual({ slug: 'červená' });
+  });
+
+  test('treats malformed percent-encoding as no match instead of throwing', () => {
+    expect(() =>
+      matchPathPattern('/produkty/%E0%A4%A', '/produkty/:slug'),
+    ).not.toThrow();
+    expect(
+      matchPathPattern('/produkty/%E0%A4%A', '/produkty/:slug'),
+    ).toBeNull();
+  });
+
+  test('keeps literal bracket segments in pathnames (no pattern rewrite)', () => {
+    expect(matchPathPattern('/produkty/[x]', '/produkty/:slug')).toEqual({
+      slug: '[x]',
+    });
+  });
+
+  test('resolveLocalisedPath returns malformed paths unchanged', () => {
+    const localisedUrls = {
+      '/products/:slug': {
+        en: '/products/:slug',
+        cs: '/produkty/:slug',
+      },
+    };
+
+    expect(
+      resolveLocalisedPath(
+        '/produkty/%E0%A4%A',
+        'en',
+        ['en', 'cs'],
+        localisedUrls,
+      ),
+    ).toBe('/produkty/%E0%A4%A');
+  });
+});
+
 describe('i18n server API prefix skips', () => {
   test('collects API route prefixes and normalized BFF config prefixes', () => {
     expect(
@@ -272,6 +436,66 @@ describe('i18n server API prefix skips', () => {
     }
   });
 
+  test('canonical redirect survives malformed percent-encoding', async () => {
+    const middlewares: any[] = [];
+    const routes = [{ entryName: 'main', entryPath: '', urlPath: '/' }];
+    let prepare: (() => void) | undefined;
+
+    i18nServerPlugin({
+      localeDetection: {
+        fallbackLanguage: 'en',
+        languages: ['en', 'cs'],
+        localePathRedirect: true,
+        localisedUrls: {
+          '/products/:slug': {
+            en: '/products/:slug',
+            cs: '/produkty/:slug',
+          },
+        },
+      },
+      staticRoutePrefixes: [],
+    }).setup({
+      getServerConfig: () => ({}),
+      getServerContext: () => ({ middlewares, routes }),
+      onPrepare: fn => {
+        prepare = fn;
+      },
+    } as any);
+
+    prepare?.();
+
+    const redirectMiddleware = middlewares.find(
+      middleware => middleware.name === 'i18n-server-middleware',
+    );
+    const createContext = (pathname: string) =>
+      ({
+        req: {
+          url: `http://localhost${pathname}`,
+          header: () => ({ host: 'localhost' }),
+        },
+        get: () => null,
+        redirect: (url: string) => ({ redirectedTo: url }),
+      }) as any;
+
+    // Sanity: well-formed non-canonical slugs still redirect.
+    const redirected = await redirectMiddleware.handler(
+      createContext('/cs/products/bota'),
+      async () => {},
+    );
+    expect(redirected).toEqual({ redirectedTo: '/cs/produkty/bota' });
+
+    // Malformed encoding must fall through to next() instead of throwing.
+    let nextCalls = 0;
+    const response = await redirectMiddleware.handler(
+      createContext('/cs/produkty/%E0%A4%A'),
+      async () => {
+        nextCalls++;
+      },
+    );
+    expect(response).toBeUndefined();
+    expect(nextCalls).toBe(1);
+  });
+
   test('uses /api as the BFF prefix when BFF config is present without prefix', async () => {
     const middlewares: any[] = [];
     const routes = [{ entryName: 'main', entryPath: '', urlPath: '/' }];

package/tests/routerAdapter.test.tsx

@@ -1,4 +1,5 @@
 import {
+  applyRouterRuntimeState,
   InternalRuntimeContext,
   RuntimeContext,
 } from '@modern-js/runtime/context';
@@ -28,11 +29,18 @@ const requestContext = {
   response: {},
 };
 
-const TanstackLink = ({ to, children, ...props }: any) => (
-  <a href={to} data-router-link="tanstack" {...props}>
-    {children}
-  </a>
-);
+const capturedTanstackLinkProps: any[] = [];
+
+const TanstackLink = ({ to, children, ...props }: any) => {
+  capturedTanstackLinkProps.push({ to, ...props });
+  const { prefetch: _prefetch, preload: _preload, ...anchorProps } = props;
+
+  return (
+    <a href={to} data-router-link="tanstack" {...anchorProps}>
+      {children}
+    </a>
+  );
+};
 
 function createI18nInstance(language = 'en'): I18nInstance {
   return {
@@ -52,22 +60,23 @@ function createRuntimeContext(
   router: unknown,
   framework: 'tanstack' | 'react-router',
 ) {
-  return {
+  const context = {
     isBrowser: true,
     requestContext,
     context: requestContext,
-    routerFramework: framework,
-    routerInstance: router,
-    routerRuntime: {
-      framework,
-      instance: router,
-    },
     router: {
       ...(framework === 'tanstack'
         ? { Link: TanstackLink, useRouter: () => router }
         : { useLocation: () => undefined, useHref: () => undefined }),
     },
   } as any;
+
+  applyRouterRuntimeState(context, {
+    framework,
+    instance: router,
+  });
+
+  return context;
 }
 
 function createTanstackRuntimeContext(router: unknown) {
@@ -236,6 +245,7 @@ describe('i18n router adapter', () => {
   afterEach(() => {
     cleanup(rendered);
     rendered = undefined;
+    capturedTanstackLinkProps.length = 0;
     window.history.replaceState(null, '', '/');
   });
 
@@ -265,6 +275,70 @@ describe('i18n router adapter', () => {
     expect(link?.getAttribute('data-router-link')).toBe('tanstack');
   });
 
+  test('forwards warmup props through I18nLink with a localized string target', async () => {
+    const router = createTanstackRouter('/cs/podminky-pouzivani', 'cs');
+    rendered = await renderWithRuntime(
+      <ModernI18nProvider
+        value={{
+          language: 'cs',
+          i18nInstance: createI18nInstance('cs'),
+          languages: ['en', 'cs'],
+          localePathRedirect: true,
+          localisedUrls,
+        }}
+      >
+        <I18nLink
+          to="/terms-of-service"
+          data-testid="terms-link"
+          prefetch="viewport"
+          preload="intent"
+        >
+          Terms
+        </I18nLink>
+      </ModernI18nProvider>,
+      createTanstackRuntimeContext(router),
+    );
+
+    const linkProps = capturedTanstackLinkProps.at(-1);
+    // TanStack has no `prefetch` prop: the explicit native `preload` wins and
+    // `prefetch` must not be forwarded.
+    expect(linkProps).toMatchObject({
+      to: '/cs/podminky-pouzivani',
+      preload: 'intent',
+    });
+    expect(linkProps.prefetch).toBeUndefined();
+  });
+
+  test('does not leak warmup props to fallback anchors', async () => {
+    rendered = await renderI18nRoot(
+      <ModernI18nProvider
+        value={{
+          language: 'cs',
+          i18nInstance: createI18nInstance('cs'),
+          languages: ['en', 'cs'],
+          localePathRedirect: true,
+          localisedUrls,
+        }}
+      >
+        <I18nLink
+          to="/terms-of-service"
+          data-testid="terms-link"
+          prefetch="none"
+          preload={false}
+        >
+          Terms
+        </I18nLink>
+      </ModernI18nProvider>,
+    );
+
+    const link = rendered.container.querySelector<HTMLAnchorElement>(
+      '[data-testid="terms-link"]',
+    );
+    expect(link?.getAttribute('href')).toBe('/cs/podminky-pouzivani');
+    expect(link?.hasAttribute('prefetch')).toBe(false);
+    expect(link?.hasAttribute('preload')).toBe(false);
+  });
+
   test('uses TanStack-shaped replacement when changeLanguage updates the URL', async () => {
     window.history.replaceState(
       null,

package/tests/type-fixture/linkTypes.fixture.tsx

@@ -0,0 +1,51 @@
+import { Link } from '@modern-js/plugin-i18n/runtime';
+
+declare module '@modern-js/plugin-i18n/runtime' {
+  interface UltramodernCanonicalRoutes {
+    '/': Record<string, never>;
+    '/talks': Record<string, never>;
+    '/talks/$slug': { slug: string };
+  }
+}
+
+// --- valid uses ---
+
+// Known route with required params: must compile.
+const _a = <Link to="/talks/$slug" params={{ slug: 'x' }} />;
+
+// Known route without params: must compile.
+const _b = <Link to="/talks" />;
+
+// Root route: must compile.
+const _c = <Link to="/" />;
+
+// Canonical path with hash suffix: must compile.
+const _d = <Link to="/#work-with-me" />;
+
+// Canonical path with query and hash: must compile.
+const _e = <Link to="/talks?tag=x#abstract" />;
+
+// Bare hash: must compile.
+const _f = <Link to="#hash" />;
+
+// External HTTPS URL: must compile.
+const _g = <Link to="https://example.com" />;
+
+// Dynamic (computed) value — escape hatch: must compile.
+declare function compute(): string;
+const dynamic: string = compute();
+const _h = <Link to={dynamic} />;
+
+// --- invalid uses (each preceded by @ts-expect-error) ---
+
+// Unknown route.
+// @ts-expect-error
+const _i = <Link to="/talkz" />;
+
+// Known param route but params prop is missing.
+// @ts-expect-error
+const _j = <Link to="/talks/$slug" />;
+
+// Known route without params but params are provided (forbidden).
+// @ts-expect-error
+const _k = <Link to="/talks" params={{ slug: 'x' }} />;

package/tests/type-fixture/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "strict": true,
+    "moduleResolution": "Bundler",
+    "module": "Preserve",
+    "noEmit": true,
+    "skipLibCheck": true,
+    "lib": ["ESNext", "DOM"],
+    "paths": {
+      "@modern-js/plugin-i18n/runtime": ["../../src/runtime/index.tsx"]
+    }
+  },
+  "include": ["*.tsx", "*.ts"]
+}