next-tongue 0.9.2 → 0.9.3

package/README.md

@@ -37,10 +37,14 @@ export default withTongue({ cacheComponents: true });
 ```
 
 ```ts
-// proxy.ts
+// proxy.ts — locales + defaultLocale are required
 import { createProxy } from 'next-tongue/proxy';
 
-export const proxy = createProxy();
+export const proxy = createProxy({
+  locales: ['en', 'de'],
+  defaultLocale: 'en',
+  prefix: 'as-needed',
+});
 export const config = { matcher: ['/((?!api|_next|.*\\..*).*)'] };
 ```
 

package/dist/cli/init.d.ts

@@ -10,3 +10,10 @@ export type InitCliOptions = {
     quiet?: boolean;
 };
 export declare function cmdInit(opts: InitCliOptions): Promise<void>;
+/** Prefer src/app when present; otherwise app/. */
+export declare function detectAppRoot(cwd: string): Promise<'app' | 'src/app'>;
+/**
+ * Where to write proxy.ts. Returns null when the project already has proxy/middleware
+ * (caller should compose manually).
+ */
+export declare function detectProxyPath(cwd: string, appRoot: 'app' | 'src/app'): Promise<string | null>;

package/dist/cli/init.js

@@ -31,6 +31,9 @@ export async function cmdInit(opts) {
         process.exitCode = 2;
         return;
     }
+    const appRoot = await detectAppRoot(cwd);
+    const hasRootLayout = await hasFile(cwd, `${appRoot}/layout.tsx`, `${appRoot}/layout.ts`, `${appRoot}/layout.jsx`, `${appRoot}/layout.js`);
+    const proxyPath = await detectProxyPath(cwd, appRoot);
     const plans = [];
     plans.push({
         path: 'tongue.config.ts',
@@ -46,68 +49,38 @@ export default defineConfig({
 `,
     });
     for (const locale of locales) {
-        const sample = locale === defaultLocale
-            ? {
-                home: {
-                    title: 'Welcome, {name}!',
-                    body: 'Scaffolded by tongue init.',
-                },
-            }
-            : {
-                home: {
-                    title: 'Welcome, {name}!',
-                    body: 'Scaffolded by tongue init.',
-                },
-            };
+        const sample = {
+            home: {
+                title: 'Welcome, {name}!',
+                body: 'Scaffolded by tongue init.',
+            },
+        };
         plans.push({
             path: `messages/${locale}.json`,
             kind: 'create',
             content: `${JSON.stringify(sample, null, 2)}\n`,
         });
     }
+    if (proxyPath) {
+        plans.push({
+            path: proxyPath,
+            kind: 'create',
+            content: proxyScaffold(locales, defaultLocale, prefix),
+        });
+    }
+    else if (!opts.quiet) {
+        console.log('tongue init: existing proxy/middleware detected — compose createProxy({ locales, defaultLocale, … }) yourself (see docs/routing-and-proxy.md).');
+    }
+    const layoutPath = `${appRoot}/[locale]/layout.tsx`;
     plans.push({
-        path: 'proxy.ts',
+        path: layoutPath,
         kind: 'create',
-        content: `import { createProxy } from 'next-tongue/proxy';
-
-export const proxy = createProxy();
-export const config = {
-  matcher: ['/((?!api|_next|.*\\\\..*).*)'],
-};
-`,
+        content: hasRootLayout
+            ? nestedLocaleLayout()
+            : rootLocaleLayout(),
     });
     plans.push({
-        path: 'app/[locale]/layout.tsx',
-        kind: 'create',
-        content: `import { notFound } from 'next/navigation';
-import { TongueProvider } from 'next-tongue/client';
-import { getDir, isLocale, localeParams } from 'next-tongue/server';
-import { ensureTongue } from '#tongue/runtime';
-
-ensureTongue();
-export const generateStaticParams = localeParams;
-
-export default async function RootLayout({
-  children,
-  params,
-}: {
-  children: React.ReactNode;
-  params: Promise<{ locale: string }>;
-}) {
-  const { locale } = await params;
-  if (!isLocale(locale)) notFound();
-  return (
-    <html lang={locale} dir={getDir(locale)}>
-      <body>
-        <TongueProvider locale={locale}>{children}</TongueProvider>
-      </body>
-    </html>
-  );
-}
-`,
-    });
-    plans.push({
-        path: 'app/[locale]/page.tsx',
+        path: `${appRoot}/[locale]/page.tsx`,
         kind: 'create',
         content: `import { getT } from 'next-tongue/server';
 import { ensureTongue } from '#tongue/runtime';
@@ -160,7 +133,7 @@ export default withTongue(nextConfig);
 `,
         });
     }
-    // tsconfig include
+    // tsconfig: include + paths for #tongue/* (tsc does not resolve package.json imports)
     if (await exists(join(cwd, 'tsconfig.json'))) {
         const abs = join(cwd, 'tsconfig.json');
         const raw = await readFile(abs, 'utf8');
@@ -169,6 +142,12 @@ export default withTongue(nextConfig);
             const include = new Set(ts.include ?? ['**/*.ts', '**/*.tsx']);
             include.add('.tongue/types.d.ts');
             ts.include = [...include];
+            ts.compilerOptions = ts.compilerOptions ?? {};
+            const paths = { ...(ts.compilerOptions.paths ?? {}) };
+            if (!paths['#tongue/*']) {
+                paths['#tongue/*'] = ['./.tongue/*'];
+            }
+            ts.compilerOptions.paths = paths;
             const next = `${JSON.stringify(ts, null, 2)}\n`;
             if (next !== raw) {
                 plans.push({ path: 'tsconfig.json', kind: 'merge', content: next });
@@ -242,9 +221,114 @@ export default withTongue(nextConfig);
         }
     }
     if (!opts.quiet) {
+        if (hasRootLayout) {
+            console.log('tongue init: existing root layout detected — set <html lang={locale} dir={…}> on the root layout (or a client HtmlLang), not under [locale].');
+        }
         console.log('tongue init: done. Run `npx tongue build` (or start next) so `.tongue/` is generated.');
     }
 }
+function proxyScaffold(locales, defaultLocale, prefix) {
+    return `import { createProxy } from 'next-tongue/proxy';
+
+// locales/defaultLocale must match tongue.config.ts (or import from '#tongue/runtime' after \`tongue build\`).
+export const proxy = createProxy({
+  locales: ${JSON.stringify(locales)},
+  defaultLocale: ${JSON.stringify(defaultLocale)},
+  prefix: ${JSON.stringify(prefix)},
+});
+
+export const config = {
+  matcher: ['/((?!api|_next|.*\\\\..*).*)'],
+};
+`;
+}
+/** Greenfield: [locale] is the root layout and owns <html>. */
+function rootLocaleLayout() {
+    return `import { notFound } from 'next/navigation';
+import { TongueProvider } from 'next-tongue/client';
+import { getDir, isLocale, localeParams } from 'next-tongue/server';
+import { ensureTongue } from '#tongue/runtime';
+
+ensureTongue();
+export const generateStaticParams = localeParams;
+
+export default async function LocaleLayout({
+  children,
+  params,
+}: {
+  children: React.ReactNode;
+  params: Promise<{ locale: string }>;
+}) {
+  const { locale } = await params;
+  if (!isLocale(locale)) notFound();
+  return (
+    <html lang={locale} dir={getDir(locale)}>
+      <body>
+        <TongueProvider locale={locale}>{children}</TongueProvider>
+      </body>
+    </html>
+  );
+}
+`;
+}
+/**
+ * App already has app/layout.tsx — Next only allows <html> there.
+ * [locale] layout wraps children only.
+ */
+function nestedLocaleLayout() {
+    return `import { notFound } from 'next/navigation';
+import { TongueProvider } from 'next-tongue/client';
+import { isLocale, localeParams } from 'next-tongue/server';
+import { ensureTongue } from '#tongue/runtime';
+
+ensureTongue();
+export const generateStaticParams = localeParams;
+
+export default async function LocaleLayout({
+  children,
+  params,
+}: {
+  children: React.ReactNode;
+  params: Promise<{ locale: string }>;
+}) {
+  const { locale } = await params;
+  if (!isLocale(locale)) notFound();
+  // Keep html lang/dir on the root layout (or sync via a client helper).
+  return <TongueProvider locale={locale}>{children}</TongueProvider>;
+}
+`;
+}
+/** Prefer src/app when present; otherwise app/. */
+export async function detectAppRoot(cwd) {
+    if (await exists(join(cwd, 'src', 'app')))
+        return 'src/app';
+    if (await exists(join(cwd, 'app')))
+        return 'app';
+    if (await exists(join(cwd, 'src')))
+        return 'src/app';
+    return 'app';
+}
+/**
+ * Where to write proxy.ts. Returns null when the project already has proxy/middleware
+ * (caller should compose manually).
+ */
+export async function detectProxyPath(cwd, appRoot) {
+    const existing = [
+        'proxy.ts',
+        'proxy.js',
+        'src/proxy.ts',
+        'src/proxy.js',
+        'middleware.ts',
+        'middleware.js',
+        'src/middleware.ts',
+        'src/middleware.js',
+    ];
+    for (const p of existing) {
+        if (await exists(join(cwd, p)))
+            return null;
+    }
+    return appRoot.startsWith('src/') ? 'src/proxy.ts' : 'proxy.ts';
+}
 function wrapNextConfig(src, staticExport) {
     let out = src;
     if (!/withTongue/.test(out)) {
@@ -258,6 +342,13 @@ function wrapNextConfig(src, staticExport) {
     }
     return out;
 }
+async function hasFile(cwd, ...rels) {
+    for (const rel of rels) {
+        if (await exists(join(cwd, rel)))
+            return true;
+    }
+    return false;
+}
 async function exists(path) {
     try {
         await access(path);

package/dist/compiler/validate/a11y.d.ts

@@ -1,7 +1,12 @@
 import type { ResolvedTongueConfig } from '../../config/types.js';
 import type { CheckIssue } from '../../cli/check-types.js';
 /**
- * Static analysis: `[locale]` layout should set `<html lang={locale}>` and
- * `dir={getDir(locale)}` (or equivalent) for RTL locales.
+ * Static analysis: some layout in the tree should set `<html lang={locale}>`
+ * and `dir={getDir(locale)}` for RTL.
+ *
+ * Next.js only allows `<html>` on the **root** layout. When `app/layout` (or
+ * `src/app/layout`) exists beside `app/[locale]`, check the root layout for
+ * lang/dir (or any client sync of `document.documentElement.lang`). Otherwise
+ * check the `[locale]` layout (greenfield pattern).
  */
 export declare function validateA11y(config: ResolvedTongueConfig, cwd: string): Promise<CheckIssue[]>;

package/dist/compiler/validate/a11y.js

@@ -7,60 +7,116 @@ function severityFor(level) {
     return level === 'error' ? 'error' : 'warn';
 }
 /**
- * Static analysis: `[locale]` layout should set `<html lang={locale}>` and
- * `dir={getDir(locale)}` (or equivalent) for RTL locales.
+ * Static analysis: some layout in the tree should set `<html lang={locale}>`
+ * and `dir={getDir(locale)}` for RTL.
+ *
+ * Next.js only allows `<html>` on the **root** layout. When `app/layout` (or
+ * `src/app/layout`) exists beside `app/[locale]`, check the root layout for
+ * lang/dir (or any client sync of `document.documentElement.lang`). Otherwise
+ * check the `[locale]` layout (greenfield pattern).
  */
 export async function validateA11y(config, cwd) {
     const sev = severityFor(config.strict.a11y);
     if (!sev)
         return [];
-    const layouts = await findLocaleLayouts(cwd);
-    if (layouts.length === 0) {
+    const localeLayouts = await findLocaleLayouts(cwd);
+    if (localeLayouts.length === 0) {
         return [
             {
                 check: 'a11y',
                 severity: sev,
-                message: 'No app/[locale]/layout.* found — cannot verify <html lang> / dir',
+                message: 'No app/[locale]/layout.* (or src/app/[locale]/layout.*) found — cannot verify lang/dir',
             },
         ];
     }
-    const issues = [];
+    const rootLayouts = await findRootLayouts(cwd);
+    const checkFiles = rootLayouts.length > 0
+        ? [...rootLayouts, ...localeLayouts]
+        : localeLayouts;
     const rtlLocales = config.locales.filter((l) => getDir(l) === 'rtl');
-    for (const file of layouts) {
+    let anyLang = false;
+    let anyDir = false;
+    const sources = [];
+    for (const file of checkFiles) {
         const src = await readFile(file, 'utf8');
-        const hasLang = /<html[^>]*\blang=\{/.test(src) ||
-            /<html[^>]*\blang=["']/.test(src) ||
-            /\blang=\{locale\}/.test(src);
-        const hasDir = /<html[^>]*\bdir=\{/.test(src) ||
-            /<html[^>]*\bdir=["']/.test(src) ||
-            /\bdir=\{getDir\(/.test(src) ||
-            /\bdir=\{.*getDir/.test(src);
-        if (!hasLang) {
-            issues.push({
-                check: 'a11y',
-                severity: sev,
-                message: 'Root locale layout <html> is missing lang={locale} (or lang=…)',
-                file: file.replace(cwd + '/', '').replace(cwd + '\\', ''),
-            });
-        }
-        if (rtlLocales.length > 0 && !hasDir) {
-            issues.push({
-                check: 'a11y',
-                severity: sev,
-                message: `Root locale layout <html> is missing dir={getDir(locale)} (RTL locales: ${rtlLocales.join(', ')})`,
-                file: file.replace(cwd + '/', '').replace(cwd + '\\', ''),
-            });
-        }
+        sources.push(src);
+        if (hasLangHint(src))
+            anyLang = true;
+        if (hasDirHint(src))
+            anyDir = true;
+    }
+    const issues = [];
+    const rel = (rootLayouts[0] ?? localeLayouts[0] ?? '').replace(cwd + '/', '').replace(cwd + '\\', '') ||
+        'layout';
+    if (!anyLang) {
+        issues.push({
+            check: 'a11y',
+            severity: sev,
+            message: rootLayouts.length
+                ? 'Set <html lang={locale}> on the root layout (Next disallows <html> under [locale]), or sync document.documentElement.lang from the locale'
+                : 'Root locale layout <html> is missing lang={locale} (or lang=…)',
+            file: rel,
+        });
+    }
+    if (rtlLocales.length > 0 && !anyDir) {
+        issues.push({
+            check: 'a11y',
+            severity: sev,
+            message: rootLayouts.length
+                ? `Set <html dir={…}> on the root layout for RTL locales (${rtlLocales.join(', ')}), or sync document.documentElement.dir`
+                : `Root locale layout <html> is missing dir={getDir(locale)} (RTL locales: ${rtlLocales.join(', ')})`,
+            file: rel,
+        });
     }
     return issues;
 }
+function hasLangHint(src) {
+    return (/<html[^>]*\blang=\{/.test(src) ||
+        /<html[^>]*\blang=["']/.test(src) ||
+        /\blang=\{locale\}/.test(src) ||
+        /document\.documentElement\.lang/.test(src) ||
+        /\.lang\s*=/.test(src));
+}
+function hasDirHint(src) {
+    return (/<html[^>]*\bdir=\{/.test(src) ||
+        /<html[^>]*\bdir=["']/.test(src) ||
+        /\bdir=\{getDir\(/.test(src) ||
+        /\bdir=\{.*getDir/.test(src) ||
+        /document\.documentElement\.dir/.test(src));
+}
 async function findLocaleLayouts(cwd) {
-    const candidates = [
-        join(cwd, 'app', '[locale]'),
-        join(cwd, 'src', 'app', '[locale]'),
-    ];
+    return findLayoutsUnder(cwd, ['app/[locale]', 'src/app/[locale]']);
+}
+/** Root layouts that are siblings of [locale], not under it. */
+async function findRootLayouts(cwd) {
     const out = [];
-    for (const root of candidates) {
+    for (const dir of ['app', 'src/app']) {
+        const abs = join(cwd, dir);
+        try {
+            if (!(await stat(abs)).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        // Only treat as "existing root" when [locale] also lives under the same app dir
+        // (otherwise greenfield [locale]-as-root still owns <html>).
+        const hasLocale = await existsDir(join(abs, '[locale]'));
+        if (!hasLocale)
+            continue;
+        const entries = await readdir(abs);
+        for (const name of entries) {
+            if (/^layout\.(tsx|ts|jsx|js)$/.test(name)) {
+                out.push(join(abs, name));
+            }
+        }
+    }
+    return out;
+}
+async function findLayoutsUnder(cwd, roots) {
+    const out = [];
+    for (const rel of roots) {
+        const root = join(cwd, ...rel.split('/'));
         try {
             if (!(await stat(root)).isDirectory())
                 continue;
@@ -77,3 +133,11 @@ async function findLocaleLayouts(cwd) {
     }
     return out;
 }
+async function existsDir(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/next/with-tongue.js

@@ -43,16 +43,19 @@ export function withTongue(nextConfig = {}, options = {}) {
             },
         ],
     };
+    const existingRules = input.turbopack?.rules ?? {};
     const turbopack = {
         ...(input.turbopack ?? {}),
         resolveAlias: {
             ...(input.turbopack?.resolveAlias ?? {}),
             '#tongue': outDir,
         },
+        // Appends the call-site loader onto any existing `*.tsx` / `*.jsx` rules
+        // (Next accepts a rule or an array of rules per glob).
         rules: {
-            ...(input.turbopack?.rules ?? {}),
-            '*.tsx': tongueLoaderRule,
-            '*.jsx': tongueLoaderRule,
+            ...existingRules,
+            '*.tsx': appendTurbopackRule(existingRules['*.tsx'], tongueLoaderRule),
+            '*.jsx': appendTurbopackRule(existingRules['*.jsx'], tongueLoaderRule),
         },
     };
     const userWebpack = input.webpack;
@@ -90,6 +93,12 @@ export function withTongue(nextConfig = {}, options = {}) {
         webpack,
     };
 }
+/** Merge a tongue loader rule with any pre-existing turbopack rule for the same glob. */
+function appendTurbopackRule(existing, rule) {
+    if (existing == null)
+        return rule;
+    return Array.isArray(existing) ? [...existing, rule] : [existing, rule];
+}
 /** Sync peek: `routing.rootParams: true` in tongue.config (ADR 0007 / #24). */
 function peekRootParamsFlag(cwd, configPath) {
     const candidates = configPath

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-tongue",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "description": "Compiler-first, type-safe i18n for the Next.js 16 App Router",
   "license": "MIT",
   "type": "module",