next-tongue 0.9.4 → 0.9.6

package/dist/client/dev-registry.js

@@ -13,15 +13,28 @@ function store() {
             rendered: [],
             listeners: new Set(),
             snapshot: null,
+            notifyScheduled: false,
         };
     }
     return g.__nextTongueDev;
 }
+/**
+ * Invalidate snapshot and notify subscribers **after** the current render.
+ * Synchronous notify from inside `t()` (render) caused
+ * "Cannot update DevOverlay while rendering Header".
+ */
 function notify() {
     const s = store();
     s.snapshot = null;
-    for (const l of s.listeners)
-        l();
+    if (s.notifyScheduled)
+        return;
+    s.notifyScheduled = true;
+    queueMicrotask(() => {
+        const st = store();
+        st.notifyScheduled = false;
+        for (const l of st.listeners)
+            l();
+    });
 }
 export function tongueDevLoaded(namespace, key) {
     const fullKey = namespace === '_root' || namespace === '' ? key : `${namespace}.${key}`;

package/dist/client/index.js

@@ -82,19 +82,19 @@ export function useT(namespace) {
     });
 }
 /**
- * Stub used when the call-site loader owns message delivery. Calling the
- * function (or .rich / .dynamic / .ns) means a key was not rewritten — usually
- * a missing loader or a non-literal key without `t.dynamic({ from })`.
+ * Stub used when the call-site loader owns message delivery. Literal `t('key')`
+ * and `t.dynamic(key, { from })` should be rewritten by the loader; if you still
+ * hit this, the rewrite did not run (or a key was not in `from`).
  */
 function createLoaderStubT(locale, ns) {
-    const fail = () => {
-        throw new TongueError('TONGUE_E_NO_PROVIDER', `useT('${ns}') call was not rewritten to a per-key import. Ensure withTongue() is applied, or pass loadNamespace to TongueProvider. Prefer getT on the server for static copy; for dynamic keys use t.dynamic(key, { from: [...] }).`);
+    const fail = (kind) => {
+        throw new TongueError('TONGUE_E_NO_PROVIDER', `useT('${ns}') ${kind} was not rewritten to a per-key import. Ensure withTongue() is applied (loader on SSR + client). Prefer getT on the server for static copy; for dynamic keys use t.dynamic(key, { from: [...] }) so the loader can import those keys.`);
     };
-    const t = Object.assign((..._args) => fail(), {
-        rich: fail,
+    const t = Object.assign((..._args) => fail('t()'), {
+        rich: () => fail('t.rich()'),
         has: () => false,
-        dynamic: fail,
-        ns: fail,
+        dynamic: () => fail('t.dynamic()'),
+        ns: () => fail('t.ns()'),
     });
     void locale;
     return t;

package/dist/compiler/scan-keys.d.ts

@@ -8,8 +8,8 @@ export type ReferencedKey = {
 export type ScanResult = {
     refs: ReferencedKey[];
     /**
-     * Namespaces where `t(variable)` / `t.ns(...)` was seen — unused-key warnings
-     * for these namespaces are suppressed (dynamic / whole-ns usage).
+     * Namespaces where `t(variable)` / `t.ns(...)` / `t.dynamic` was seen —
+     * unused-key warnings for these namespaces are suppressed.
      */
     dynamicNamespaces: Set<string>;
 };
@@ -19,4 +19,6 @@ export type ScanResult = {
  */
 export declare function scanReferencedKeys(cwd: string, roots?: string[]): Promise<ReferencedKey[]>;
 export declare function scanKeys(cwd: string, roots?: string[]): Promise<ScanResult>;
+/** Strip // and /* *\/ comments; preserve newlines for line numbers. */
+export declare function stripComments(source: string): string;
 export declare function extractFromSource(source: string, file: string): ScanResult;

package/dist/compiler/scan-keys.js

@@ -62,14 +62,77 @@ function extname(name) {
     const i = name.lastIndexOf('.');
     return i === -1 ? '' : name.slice(i);
 }
+/** Strip // and /* *\/ comments; preserve newlines for line numbers. */
+export function stripComments(source) {
+    let out = '';
+    let i = 0;
+    while (i < source.length) {
+        const ch = source[i];
+        const next = source[i + 1];
+        // string / template — copy verbatim so // inside strings stay
+        if (ch === '"' || ch === "'" || ch === '`') {
+            const quote = ch;
+            out += ch;
+            i++;
+            while (i < source.length) {
+                const c = source[i];
+                out += c;
+                if (c === '\\' && i + 1 < source.length) {
+                    out += source[i + 1];
+                    i += 2;
+                    continue;
+                }
+                if (c === quote) {
+                    i++;
+                    break;
+                }
+                // template ${ } — shallow skip (good enough for comment strip)
+                if (quote === '`' && c === '$' && source[i + 1] === '{') {
+                    out += '{';
+                    i += 2;
+                    let depth = 1;
+                    while (i < source.length && depth > 0) {
+                        if (source[i] === '{')
+                            depth++;
+                        else if (source[i] === '}')
+                            depth--;
+                        out += source[i];
+                        i++;
+                    }
+                    continue;
+                }
+                i++;
+            }
+            continue;
+        }
+        if (ch === '/' && next === '/') {
+            while (i < source.length && source[i] !== '\n')
+                i++;
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            i += 2;
+            while (i < source.length && !(source[i] === '*' && source[i + 1] === '/')) {
+                out += source[i] === '\n' ? '\n' : ' ';
+                i++;
+            }
+            i += 2;
+            continue;
+        }
+        out += ch;
+        i++;
+    }
+    return out;
+}
 export function extractFromSource(source, file) {
+    const code = stripComments(source);
     const out = [];
     const dynamicNamespaces = new Set();
     const translators = new Map(); // var → ns
     // useT('ns') | getT('ns') | getT(locale, 'ns')
     const declRe = /(?:const|let|var)\s+(\w+)\s*=\s*(?:await\s+)?(?:useT|getT)\s*\(\s*(?:[^'"\n,]+,\s*)?(['"])([^'"]*)\2\s*\)/g;
     let m;
-    while ((m = declRe.exec(source)) !== null) {
+    while ((m = declRe.exec(code)) !== null) {
         translators.set(m[1], m[3] || '_root');
     }
     const push = (ns, key, index) => {
@@ -79,27 +142,26 @@ export function extractFromSource(source, file) {
             namespace: ns || '_root',
             key,
             file,
-            line: lineAt(source, index),
+            line: lineAt(code, index),
         });
     };
     for (const [varName, ns] of translators) {
         // Literal t('key') / t.rich('key')
         const callRe = new RegExp(`\\b${escapeRegExp(varName)}(?:\\.rich)?\\s*\\(\\s*(['"])([^'"]+)\\1`, 'g');
         let cm;
-        while ((cm = callRe.exec(source)) !== null) {
+        while ((cm = callRe.exec(code)) !== null) {
             push(ns, cm[2], cm.index);
         }
-        // t.dynamic(any, { from: ['a', 'b'] })
+        // t.dynamic(any, { from: ['a', 'b'] }) — only `from` keys become refs
         const dynRe = new RegExp(`\\b${escapeRegExp(varName)}\\.dynamic\\s*\\(`, 'g');
         let dm;
-        while ((dm = dynRe.exec(source)) !== null) {
-            const tail = source.slice(dm.index, dm.index + 400);
+        while ((dm = dynRe.exec(code)) !== null) {
+            const tail = code.slice(dm.index, dm.index + 400);
             const fromMatch = /from\s*:\s*\[([^\]]*)\]/.exec(tail);
             if (fromMatch) {
                 const keys = fromMatch[1].match(/['"]([^'"]+)['"]/g) ?? [];
                 for (const raw of keys) {
-                    const key = raw.slice(1, -1);
-                    push(ns, key, dm.index);
+                    push(ns, raw.slice(1, -1), dm.index);
                 }
             }
             dynamicNamespaces.add(ns || '_root');
@@ -107,28 +169,15 @@ export function extractFromSource(source, file) {
         // t.ns('other') — whole namespace marked dynamic
         const nsRe = new RegExp(`\\b${escapeRegExp(varName)}\\.ns\\s*\\(\\s*(['"])([^'"]+)\\1`, 'g');
         let nm;
-        while ((nm = nsRe.exec(source)) !== null) {
+        while ((nm = nsRe.exec(code)) !== null) {
             dynamicNamespaces.add(nm[2] || '_root');
         }
-        // Non-literal t(var) / t.rich(var) — mark namespace dynamic + harvest nearby string arrays
+        // Non-literal t(var) — suppress unused for the namespace only.
+        // Do NOT harvest unrelated string arrays (cache tags, sort keys, …).
         const nonLitRe = new RegExp(`\\b${escapeRegExp(varName)}(?:\\.rich)?\\s*\\(\\s*(?!['"])([A-Za-z_$][\\w$]*)`, 'g');
-        let nl;
-        let sawNonLit = false;
-        while ((nl = nonLitRe.exec(source)) !== null) {
-            sawNonLit = true;
+        if (nonLitRe.test(code)) {
             dynamicNamespaces.add(ns || '_root');
         }
-        if (sawNonLit) {
-            // Keys listed in string arrays in this file (e.g. KEYS.map((k) => t(k)))
-            const arrayLitRe = /\[\s*((?:['"][^'"]+['"]\s*,?\s*)+)\]/g;
-            let am;
-            while ((am = arrayLitRe.exec(source)) !== null) {
-                const keys = am[1].match(/['"]([^'"]+)['"]/g) ?? [];
-                for (const raw of keys) {
-                    push(ns, raw.slice(1, -1), am.index);
-                }
-            }
-        }
     }
     return { refs: out, dynamicNamespaces };
 }

package/dist/next/loader.d.ts

@@ -6,6 +6,8 @@
  *   const t = useT('home'); t('inbox', { count })
  * into a static import of the per-key module when the key is a string literal.
  *
+ * Also rewrites `t.dynamic(key, { from: [...] })` to a map of those imports.
+ *
  * Escape analysis: if `t` is passed around, falls back to namespace import + warning.
  */
 export type LoaderOptions = {
@@ -17,6 +19,14 @@ export type LoaderResult = {
     warnings: string[];
 };
 export declare function transformCallSites(source: string, resourcePath: string, _options?: LoaderOptions): LoaderResult;
+/**
+ * Peel leading `"use client"` / `"use server"` (and preceding comments/whitespace)
+ * so we can re-emit them before any injected imports.
+ */
+export declare function splitLeadingDirectives(source: string): {
+    directives: string;
+    body: string;
+};
 /** Webpack/Turbopack loader entry. */
 export default function tongueLoader(this: {
     resourcePath: string;

package/dist/next/loader.js

@@ -6,6 +6,8 @@
  *   const t = useT('home'); t('inbox', { count })
  * into a static import of the per-key module when the key is a string literal.
  *
+ * Also rewrites `t.dynamic(key, { from: [...] })` to a map of those imports.
+ *
  * Escape analysis: if `t` is passed around, falls back to namespace import + warning.
  */
 const USE_T_DECL = /(?:const|let|var)\s+(\w+)\s*=\s*useT\s*\(\s*(['"])([^'"]*)\2\s*\)/g;
@@ -14,10 +16,11 @@ export function transformCallSites(source, resourcePath, _options = {}) {
     if (!source.includes('useT(')) {
         return { code: source, warnings };
     }
+    const { directives, body: withoutDirs } = splitLeadingDirectives(source);
     const translators = new Map(); // varName → namespace
     let m;
     const declRe = new RegExp(USE_T_DECL.source, 'g');
-    while ((m = declRe.exec(source)) !== null) {
+    while ((m = declRe.exec(withoutDirs)) !== null) {
         translators.set(m[1], m[3] || '_root');
     }
     if (translators.size === 0) {
@@ -25,21 +28,36 @@ export function transformCallSites(source, resourcePath, _options = {}) {
     }
     // Escape analysis: if t is used beyond property calls, warn and skip rewrite
     for (const [varName, ns] of translators) {
-        if (escapes(source, varName)) {
+        if (escapes(withoutDirs, varName)) {
             warnings.push(`TONGUE_W_ESCAPE: ${resourcePath}: '${varName}' from useT('${ns}') escapes this file; importing whole namespace`);
         }
     }
     const imports = new Map();
-    let code = source;
+    let code = withoutDirs;
     for (const [varName, ns] of translators) {
-        if (escapes(source, varName))
+        if (escapes(withoutDirs, varName))
             continue;
+        // Literal t('key') / t.rich('key')
         const callRe = new RegExp(`\\b${escapeRegExp(varName)}(?:\\.rich)?\\s*\\(\\s*(['"])([^'"]+)\\1`, 'g');
         code = code.replace(callRe, (full, _q, key) => {
             const ident = safeImportIdent(ns, key);
             imports.set(`${ns}:${key}`, { ns, key, ident });
             return full;
         });
+        // t.dynamic(expr, { from: ['a', 'b'] }, values?)
+        const dynRe = new RegExp(`\\b${escapeRegExp(varName)}\\.dynamic\\s*\\(`, 'g');
+        let dm;
+        while ((dm = dynRe.exec(withoutDirs)) !== null) {
+            const tail = withoutDirs.slice(dm.index, dm.index + 500);
+            const fromMatch = /from\s*:\s*\[([^\]]*)\]/.exec(tail);
+            if (!fromMatch)
+                continue;
+            const keys = [...fromMatch[1].matchAll(/['"]([^'"]+)['"]/g)].map((x) => x[1]);
+            for (const key of keys) {
+                const ident = safeImportIdent(ns, key);
+                imports.set(`${ns}:${key}`, { ns, key, ident });
+            }
+        }
     }
     if (imports.size === 0) {
         return { code: source, warnings };
@@ -54,9 +72,29 @@ export function transformCallSites(source, resourcePath, _options = {}) {
     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();`);
-    // Second pass: replace t('key', values) / t.rich('key', values) with per-key calls
+    // Replace t.dynamic(expr, { from: [...] }, values?)
+    for (const [varName, ns] of translators) {
+        if (escapes(withoutDirs, varName))
+            continue;
+        const dynCallRe = new RegExp(`\\b${escapeRegExp(varName)}\\.dynamic\\s*\\(\\s*([^,]+?)\\s*,\\s*\\{[^}]*?from\\s*:\\s*\\[([^\\]]*)][^}]*\\}\\s*(?:,\\s*([^)]*?))?\\)`, 'g');
+        code = code.replace(dynCallRe, (_full, keyExpr, fromBody, values) => {
+            const keys = [...fromBody.matchAll(/['"]([^'"]+)['"]/g)].map((x) => x[1]);
+            const mapEntries = keys
+                .map((key) => {
+                const ident = safeImportIdent(ns, key);
+                imports.set(`${ns}:${key}`, { ns, key, ident });
+                return `${JSON.stringify(key)}: ${ident}`;
+            })
+                .join(', ');
+            const valuesArg = values != null && String(values).trim() !== ''
+                ? `, ${String(values).trim()}`
+                : '';
+            return `((__tongue_dyn) => { const __tongue_fn = __tongue_dyn[${keyExpr.trim()}]; if (!__tongue_fn) throw new Error(${JSON.stringify(`[next-tongue] t.dynamic key not in from: [${keys.join(', ')}]`)}); return __tongue_fn(${localeVar}${valuesArg}); })({ ${mapEntries} })`;
+        });
+    }
+    // Replace t('key', values) / t.rich('key', values) with per-key calls
     for (const [varName, ns] of translators) {
-        if (escapes(source, varName))
+        if (escapes(withoutDirs, varName))
             continue;
         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');
@@ -85,13 +123,40 @@ export function transformCallSites(source, resourcePath, _options = {}) {
         preamble += `import { useLocale } from 'next-tongue/client';\n`;
     }
     for (const [varName, ns] of translators) {
-        if (!escapes(source, varName))
+        if (!escapes(withoutDirs, varName))
             continue;
         preamble +=
             `process.env.NODE_ENV !== 'production' && globalThis.__tongueDevEscape?.(` +
                 `${JSON.stringify(ns || '_root')}, ${JSON.stringify(resourcePath)});\n`;
     }
-    return { code: preamble + code, warnings };
+    // "use client" / "use server" MUST be the first statement(s) — never after imports.
+    return { code: directives + preamble + code, warnings };
+}
+/**
+ * Peel leading `"use client"` / `"use server"` (and preceding comments/whitespace)
+ * so we can re-emit them before any injected imports.
+ */
+export function splitLeadingDirectives(source) {
+    let rest = source.replace(/^\uFEFF/, '');
+    const found = [];
+    while (rest.length > 0) {
+        // leading whitespace / comments
+        const lead = rest.match(/^((?:\s|\/\/[^\n]*\n|\/\*[\s\S]*?\*\/)*)/);
+        const leadLen = lead?.[0]?.length ?? 0;
+        const afterLead = rest.slice(leadLen);
+        const dir = afterLead.match(/^['"]use (client|server)['"];?[ \t]*(?:\r?\n)?/);
+        if (!dir)
+            break;
+        found.push(`"use ${dir[1]}";`);
+        rest = afterLead.slice(dir[0].length);
+    }
+    if (found.length === 0) {
+        return { directives: '', body: source.replace(/^\uFEFF/, '') };
+    }
+    return {
+        directives: found.join('\n') + '\n\n',
+        body: rest,
+    };
 }
 function escapes(source, varName) {
     const v = escapeRegExp(varName);

package/dist/next/with-tongue.js

@@ -32,9 +32,11 @@ export function withTongue(nextConfig = {}, options = {}) {
     }
     // 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
+    // rewritten on the server graph too (otherwise SSR throws without loadNamespace).
     const tongueLoaderRule = {
         condition: {
-            all: [{ not: 'foreign' }, 'browser', { content: /useT\s*\(/ }],
+            all: [{ not: 'foreign' }, { content: /useT\s*\(/ }],
         },
         loaders: [
             {
@@ -65,18 +67,17 @@ export function withTongue(nextConfig = {}, options = {}) {
             ...(config.resolve.alias ?? {}),
             '#tongue': outDir,
         };
-        if (!ctx.isServer) {
-            config.module ??= {};
-            config.module.rules = [
-                ...(config.module.rules ?? []),
-                {
-                    test: /\.[jt]sx?$/,
-                    exclude: /node_modules/,
-                    enforce: 'pre',
-                    use: [{ loader: loaderPath, options: { outDir: '.tongue' } }],
-                },
-            ];
-        }
+        // Client components SSR under webpack too — apply on both graphs.
+        config.module ??= {};
+        config.module.rules = [
+            ...(config.module.rules ?? []),
+            {
+                test: /\.[jt]sx?$/,
+                exclude: /node_modules/,
+                enforce: 'pre',
+                use: [{ loader: loaderPath, options: { outDir: '.tongue' } }],
+            },
+        ];
         return userWebpack ? userWebpack(config, ctx) : config;
     };
     const enableRootParams = peekRootParamsFlag(cwd, options.config);

package/package.json

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