next-tongue 0.9.10 → 0.9.12

package/dist/cli/check-types.d.ts

@@ -1,4 +1,4 @@
-export type CheckKind = 'missing' | 'unused' | 'undefined' | 'dynamic' | 'mismatch' | 'syntax' | 'stale' | 'a11y' | 'bidi' | 'length' | 'duplicate' | 'icu';
+export type CheckKind = 'missing' | 'unused' | 'undefined' | 'dynamic' | 'mismatch' | 'syntax' | 'stale' | 'a11y' | 'bidi' | 'length' | 'duplicate' | 'icu' | 'client-loader';
 export type CheckSeverity = 'error' | 'warn';
 export type CheckIssue = {
     check: CheckKind;

package/dist/cli/check.js

@@ -1,8 +1,10 @@
 import { loadConfig } from '../config/load-config.js';
 import { validateCatalog, validateStale } from '../compiler/validate/catalog.js';
 import { validateUsage } from '../compiler/validate/usage.js';
+import { validateClientLoader } from '../compiler/validate/client-loader.js';
 import { validateA11y } from '../compiler/validate/a11y.js';
 import { validateBidi } from '../compiler/validate/bidi.js';
+import { DEFAULT_SCAN_ROOTS } from '../compiler/scan-keys.js';
 import { loadLocaleMessages } from '../compiler/load-messages.js';
 import { duplicateSourceKeys, loadAndMergeSources, } from '../compiler/sources.js';
 import { validateLength } from '../compiler/validate/length.js';
@@ -20,6 +22,8 @@ export async function cmdCheck(opts) {
         ...(localeFilter ? { locales: localeFilter } : {}),
     })));
     issues.push(...(await validateUsage(config, cwd)));
+    const scanRoots = config.scan.include.length > 0 ? config.scan.include : DEFAULT_SCAN_ROOTS;
+    issues.push(...(await validateClientLoader(cwd, scanRoots)));
     issues.push(...(await validateStale(config, cwd, {
         ...(localeFilter ? { locales: localeFilter } : {}),
     })));

package/dist/cli/init.js

@@ -32,6 +32,9 @@ export async function cmdInit(opts) {
         return;
     }
     const appRoot = await detectAppRoot(cwd);
+    if (!opts.quiet) {
+        console.log(`tongue init: using ${appRoot}/ for App Router files`);
+    }
     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 = [];
@@ -69,7 +72,9 @@ export default defineConfig({
         });
     }
     else if (!opts.quiet) {
-        console.log('tongue init: existing proxy/middleware detected — compose createProxy({ locales, defaultLocale, … }) yourself (see docs/routing-and-proxy.md).');
+        console.log('tongue init: existing proxy/middleware detected — do not overwrite. Compose like:\n\n' +
+            proxyScaffold(locales, defaultLocale, prefix) +
+            '\nSee docs/routing-and-proxy.md#composing-with-your-own-proxy-logic / hybrid routing.');
     }
     const layoutPath = `${appRoot}/[locale]/layout.tsx`;
     plans.push({

package/dist/compiler/build.js

@@ -113,8 +113,8 @@ export async function buildMessages(options) {
     const defaultMsgRel = config.messages.replaceAll('{locale}', config.defaultLocale);
     const emitLocales = localesForEmit(config);
     // Content hash for idempotency (bump CODEGEN_VERSION when emit format changes)
-    // Bump when emit shape changes (reserved idents, auto ensureTongue side-effect).
-    const CODEGEN_VERSION = 9;
+    // Bump when emit shape changes (reserved idents, auto ensureTongue, routing export).
+    const CODEGEN_VERSION = 10;
     const hash = createHash('sha256')
         .update(JSON.stringify({
         codegen: CODEGEN_VERSION,
@@ -333,9 +333,9 @@ export async function buildMessages(options) {
         !productionLocales.includes(config.pseudo.locale);
     runtimeLines.push(`export const allLocales = ${JSON.stringify([...emitLocales])};`, `const productionLocales = ${JSON.stringify(productionLocales)};`, pseudoDevOnly
         ? `export const locales = process.env.NODE_ENV === 'production' ? productionLocales : allLocales;`
-        : `export const locales = allLocales;`, `export const defaultLocale = ${JSON.stringify(config.defaultLocale)};`, `export const timeZone = ${JSON.stringify(config.timeZone)};`, config.pseudo && config.pseudo.enabled !== false
+        : `export const locales = allLocales;`, `export const defaultLocale = ${JSON.stringify(config.defaultLocale)};`, `export const prefix = ${JSON.stringify(config.routing.prefix)};`, `export const timeZone = ${JSON.stringify(config.timeZone)};`, config.pseudo && config.pseudo.enabled !== false
         ? `export const pseudoLocale = ${JSON.stringify(config.pseudo.locale)};`
-        : `export const pseudoLocale = undefined;`, `export function localeParams() {`, `  return locales.map((locale) => ({ locale }));`, `}`, `let ready = false;`, `export function ensureTongue() {`, `  if (ready) return;`, `  __setServerRuntime({`, `    locales: allLocales,`, `    defaultLocale,`, `    timeZone,`, `    rootParams: ${config.routing.rootParams ? 'true' : 'false'},`, `    loadNamespace: async (namespace) => {`, `      const messages = namespaces[namespace];`, `      if (!messages) throw new Error('[next-tongue] Unknown namespace: ' + namespace);`, `      return messages;`, `    },`, `  });`, config.pseudo && config.pseudo.enabled !== false
+        : `export const pseudoLocale = undefined;`, `/** Single source of truth for createProxy / createNavigation / TongueShell. */`, `export const routing = { locales, defaultLocale, prefix };`, `export function localeParams() {`, `  return locales.map((locale) => ({ locale }));`, `}`, `let ready = false;`, `export function ensureTongue() {`, `  if (ready) return;`, `  __setServerRuntime({`, `    locales: allLocales,`, `    defaultLocale,`, `    timeZone,`, `    rootParams: ${config.routing.rootParams ? 'true' : 'false'},`, `    loadNamespace: async (namespace) => {`, `      const messages = namespaces[namespace];`, `      if (!messages) throw new Error('[next-tongue] Unknown namespace: ' + namespace);`, `      return messages;`, `    },`, `  });`, config.pseudo && config.pseudo.enabled !== false
         ? `  configureFormatMessage({ timeZone, pseudo: { locale: ${JSON.stringify(config.pseudo.locale)}, expand: ${config.pseudo.expand} } });`
         : `  configureFormatMessage({ timeZone });`, `  ready = true;`, `}`, 
     // Side-effect: importing `#tongue/runtime` (or getT's lazy import) wires the
@@ -347,8 +347,10 @@ export async function buildMessages(options) {
         `export declare const allLocales: readonly string[];`,
         `export declare const locales: readonly string[];`,
         `export declare const defaultLocale: string;`,
+        `export declare const prefix: 'always' | 'as-needed' | 'never';`,
         `export declare const timeZone: string;`,
         `export declare const pseudoLocale: string | undefined;`,
+        `export declare const routing: { locales: readonly string[]; defaultLocale: string; prefix: 'always' | 'as-needed' | 'never' };`,
         `export declare function localeParams(): { locale: string }[];`,
         `export declare function ensureTongue(): void;`,
         ``,

package/dist/compiler/validate/client-loader.d.ts

@@ -0,0 +1,7 @@
+import type { CheckIssue } from '../../cli/check-types.js';
+/**
+ * Dry-run the call-site loader on `"use client"` files that call `useT`.
+ * Fails when rewritten output calls `useLocale` without importing it
+ * (Safari: Can't find variable: useLocale).
+ */
+export declare function validateClientLoader(cwd: string, roots?: readonly string[]): Promise<CheckIssue[]>;

package/dist/compiler/validate/client-loader.js

@@ -0,0 +1,79 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { transformCallSites } from '../../next/loader.js';
+import { DEFAULT_SCAN_ROOTS } from '../scan-keys.js';
+const SOURCE_EXT = new Set(['.ts', '.tsx', '.js', '.jsx']);
+/**
+ * Dry-run the call-site loader on `"use client"` files that call `useT`.
+ * Fails when rewritten output calls `useLocale` without importing it
+ * (Safari: Can't find variable: useLocale).
+ */
+export async function validateClientLoader(cwd, roots = DEFAULT_SCAN_ROOTS) {
+    const issues = [];
+    const files = await collectSourceFiles(cwd, roots);
+    for (const abs of files) {
+        let src;
+        try {
+            src = await readFile(abs, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        if (!/"use client"\s*;?/.test(src) && !/'use client'\s*;?/.test(src)) {
+            continue;
+        }
+        if (!/\buseT\s*\(/.test(src))
+            continue;
+        const rel = relative(cwd, abs);
+        const { code } = transformCallSites(src, rel);
+        if (!/\buseLocale\s*\(/.test(code))
+            continue;
+        const hasImport = /import\s*\{[^}]*\buseLocale\b[^}]*\}\s*from\s*['"]next-tongue\/client['"]/.test(code);
+        if (!hasImport) {
+            issues.push({
+                check: 'client-loader',
+                severity: 'error',
+                message: `Rewritten useT in "${rel}" calls useLocale() without importing it from 'next-tongue/client' (Safari ReferenceError). Upgrade next-tongue / ensure withTongue() applies the call-site loader.`,
+                file: rel,
+            });
+        }
+    }
+    return issues;
+}
+async function collectSourceFiles(cwd, roots) {
+    const out = [];
+    for (const root of roots) {
+        const abs = join(cwd, root);
+        try {
+            if (!(await stat(abs)).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        await walk(abs, out);
+    }
+    return out;
+}
+async function walk(dir, out) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const ent of entries) {
+        if (ent.name.startsWith('.'))
+            continue;
+        const abs = join(dir, ent.name);
+        if (ent.isDirectory()) {
+            if (ent.name === 'node_modules' ||
+                ent.name === '.next' ||
+                ent.name === 'dist') {
+                continue;
+            }
+            await walk(abs, out);
+        }
+        else {
+            const i = ent.name.lastIndexOf('.');
+            const ext = i === -1 ? '' : ent.name.slice(i);
+            if (SOURCE_EXT.has(ext))
+                out.push(abs);
+        }
+    }
+}

package/dist/next/loader.d.ts

@@ -28,6 +28,14 @@ export declare function splitLeadingDirectives(source: string): {
     directives: string;
     body: string;
 };
+/**
+ * Ensure `useLocale` is a real import. Looking for the identifier in the body is
+ * not enough — the loader injects `useLocale()` calls before this runs.
+ */
+export declare function ensureUseLocaleImport(code: string, preamble: string): {
+    code: string;
+    preamble: string;
+};
 /** Webpack/Turbopack loader entry. */
 export default function tongueLoader(this: {
     resourcePath: string;

package/dist/next/loader.js

@@ -67,13 +67,25 @@ export function transformCallSites(source, resourcePath, _options = {}) {
         importLines.push(`import { ${safeExport(key)} as ${ident} } from '${path}';`);
         loadedCalls.push(`process.env.NODE_ENV !== 'production' && globalThis.__tongueDevLoaded?.(${JSON.stringify(ns || '_root')}, ${JSON.stringify(key)});`);
     }
-    const localeVar = '__tongue_locale';
-    // Inject locale once after the first useT declaration
-    code = code.replace(/((?:const|let|var)\s+\w+\s*=\s*useT\s*\([^)]*\))/, `$1\n  const ${localeVar} = useLocale();`);
+    // Inject locale after every useT — one binding per translator var so each
+    // component (and multi-useT in one function) has __tongue_locale_* in scope.
+    for (const varName of translators.keys()) {
+        if (escapes(withoutDirs, varName))
+            continue;
+        const localeVar = localeVarFor(varName);
+        const declRe = new RegExp(`((?:const|let|var)\\s+${escapeRegExp(varName)}\\s*=\\s*useT\\s*\\([^)]*\\))`, 'g');
+        code = code.replace(declRe, (full) => {
+            // Idempotent if a prior pass already injected.
+            if (full.includes(localeVar))
+                return full;
+            return `${full}\n  const ${localeVar} = useLocale();`;
+        });
+    }
     // Replace t.dynamic(expr, { from }, values?) — rewrite from the end so indices stay valid
     for (const [varName, ns] of translators) {
         if (escapes(withoutDirs, varName))
             continue;
+        const localeVar = localeVarFor(varName);
         const calls = findDynamicCalls(code, varName).filter((c) => c.keys && c.keys.length > 0);
         for (let ci = calls.length - 1; ci >= 0; ci--) {
             const call = calls[ci];
@@ -96,6 +108,7 @@ export function transformCallSites(source, resourcePath, _options = {}) {
     for (const [varName, ns] of translators) {
         if (escapes(withoutDirs, varName))
             continue;
+        const localeVar = localeVarFor(varName);
         for (const { key, ident } of [...imports.values()].filter((i) => i.ns === ns)) {
             const richRe = new RegExp(`\\b${escapeRegExp(varName)}\\.rich\\s*\\(\\s*(['"])${escapeRegExp(key)}\\1\\s*(,\\s*([^)]*))?\\)`, 'g');
             code = code.replace(richRe, (_full, _q, _rest, values) => {
@@ -119,9 +132,9 @@ export function transformCallSites(source, resourcePath, _options = {}) {
     if (loadedCalls.length > 0) {
         preamble += loadedCalls.join('\n') + '\n';
     }
-    if (!/useLocale/.test(preamble + code) || !/from\s+['"]next-tongue\/client['"]/.test(code)) {
-        preamble += `import { useLocale } from 'next-tongue/client';\n`;
-    }
+    // Injected `useLocale()` calls do NOT count as an import — merge into the
+    // existing next-tongue/client import or add one (Safari ReferenceError otherwise).
+    ({ code, preamble } = ensureUseLocaleImport(code, preamble));
     for (const [varName, ns] of translators) {
         if (!escapes(withoutDirs, varName))
             continue;
@@ -178,6 +191,55 @@ function escapes(source, varName) {
 function escapeRegExp(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+/** Per-useT locale binding so each component function has its own in-scope var. */
+function localeVarFor(varName) {
+    return varName === 't' ? '__tongue_locale' : `__tongue_locale_${varName}`;
+}
+const USE_LOCALE_IMPORT = /import\s*\{([^}]*)\}\s*from\s*['"]next-tongue\/client['"]/;
+/**
+ * Ensure `useLocale` is a real import. Looking for the identifier in the body is
+ * not enough — the loader injects `useLocale()` calls before this runs.
+ */
+export function ensureUseLocaleImport(code, preamble) {
+    const combined = preamble + code;
+    if (USE_LOCALE_IMPORT.test(combined) && /\buseLocale\b/.test(combined.match(USE_LOCALE_IMPORT)?.[1] ?? '')) {
+        return { code, preamble };
+    }
+    if (USE_LOCALE_IMPORT.test(code)) {
+        return {
+            code: code.replace(USE_LOCALE_IMPORT, (full, specs) => {
+                if (/\buseLocale\b/.test(specs))
+                    return full;
+                const parts = specs
+                    .split(',')
+                    .map((s) => s.trim())
+                    .filter(Boolean);
+                parts.push('useLocale');
+                return full.replace(specs, ` ${parts.join(', ')} `);
+            }),
+            preamble,
+        };
+    }
+    if (USE_LOCALE_IMPORT.test(preamble)) {
+        return {
+            code,
+            preamble: preamble.replace(USE_LOCALE_IMPORT, (full, specs) => {
+                if (/\buseLocale\b/.test(specs))
+                    return full;
+                const parts = specs
+                    .split(',')
+                    .map((s) => s.trim())
+                    .filter(Boolean);
+                parts.push('useLocale');
+                return full.replace(specs, ` ${parts.join(', ')} `);
+            }),
+        };
+    }
+    return {
+        code,
+        preamble: preamble + `import { useLocale } from 'next-tongue/client';\n`,
+    };
+}
 function safeImportIdent(ns, key) {
     return `__tongue_${(ns + '_' + key).replace(/[^A-Za-z0-9_]/g, '_')}`;
 }

package/dist/next/with-tongue.js

@@ -18,6 +18,7 @@ export function withTongue(nextConfig = {}, options = {}) {
     const input = nextConfig;
     if (!options.skipBuild) {
         runCodegenSync(cwd, options.config);
+        warnMissingTongueRuntime(cwd);
         void loadConfig({
             cwd,
             ...(options.config != null ? { configPath: options.config } : {}),
@@ -33,6 +34,9 @@ export function withTongue(nextConfig = {}, options = {}) {
             console.warn('[next-tongue] Could not start watcher:', err instanceof Error ? err.message : err);
         });
     }
+    else {
+        warnMissingTongueRuntime(cwd);
+    }
     // Next 16: content must be RegExp; omit `as` when returning the same module type
     // (using `as: '*.tsx'` previously doubled extensions → `file.tsx.tsx`).
     // Do NOT gate on `browser` — client components still SSR, and useT must be
@@ -171,6 +175,12 @@ function resolveLoaderPath() {
     const here = dirname(fileURLToPath(import.meta.url));
     return resolve(here, 'loader.js');
 }
+function warnMissingTongueRuntime(cwd) {
+    const runtime = join(cwd, '.tongue', 'runtime.js');
+    if (!existsSync(runtime)) {
+        console.warn('[next-tongue] `.tongue/runtime.js` is missing. Run `npx tongue build` (or use `"build": "tongue build && next build"`). `next dev` without a recent build leaves getT/useT unwired.');
+    }
+}
 function runCodegenSync(cwd, configPath) {
     const here = dirname(fileURLToPath(import.meta.url));
     const bin = resolve(here, '../../bin/tongue.js');

package/package.json

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