next-tongue 0.9.3 → 0.9.4

package/dist/client/dev-registry.js

@@ -12,12 +12,15 @@ function store() {
             escapes: new Map(),
             rendered: [],
             listeners: new Set(),
+            snapshot: null,
         };
     }
     return g.__nextTongueDev;
 }
 function notify() {
-    for (const l of store().listeners)
+    const s = store();
+    s.snapshot = null;
+    for (const l of s.listeners)
         l();
 }
 export function tongueDevLoaded(namespace, key) {
@@ -74,13 +77,16 @@ export function subscribeTongueDev(listener) {
 }
 export function getTongueDevSnapshot() {
     const s = store();
-    return {
+    if (s.snapshot)
+        return s.snapshot;
+    s.snapshot = {
         loaded: [...s.loaded.values()],
         missing: [...s.missing.values()],
         fallbacks: [...s.fallbacks.values()],
         escapes: [...s.escapes.values()],
         rendered: [...s.rendered],
     };
+    return s.snapshot;
 }
 /** @internal test helper */
 export function __resetTongueDev() {

package/dist/client/index.js

@@ -68,8 +68,11 @@ export function useFormat() {
 export function useT(namespace) {
     const ns = (namespace ?? '_root');
     const { locale, loadNamespace } = useTongue();
+    // Literal `t('key')` is rewritten by the call-site loader to per-key imports;
+    // `useT()` itself must still be safe during SSR without loadNamespace.
+    // Invoking the returned `t` without a rewrite (dynamic/escaped) throws below.
     if (!loadNamespace) {
-        throw new TongueError('TONGUE_E_NO_PROVIDER', `useT('${String(ns)}') needs the call-site loader (or pass loadNamespace to TongueProvider). Prefer translating on the server with getT and passing strings.`);
+        return createLoaderStubT(locale, String(ns));
     }
     const messages = loadNamespace(ns);
     return createT({
@@ -78,6 +81,24 @@ export function useT(namespace) {
         loadNamespace,
     });
 }
+/**
+ * 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 })`.
+ */
+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 t = Object.assign((..._args) => fail(), {
+        rich: fail,
+        has: () => false,
+        dynamic: fail,
+        ns: fail,
+    });
+    void locale;
+    return t;
+}
 export function getClientLocales() {
     return clientLocales;
 }

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

@@ -5,9 +5,18 @@ export type ReferencedKey = {
     file: string;
     line: number;
 };
+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).
+     */
+    dynamicNamespaces: Set<string>;
+};
 /**
  * Find `t('key')` / `t.rich('key')` under a known `useT`/`getT` namespace,
- * plus bare `useT('ns')` / `getT('ns')` for namespace awareness.
+ * plus `t.dynamic(..., { from })` declared keys and dynamic `t(var)` markers.
  */
 export declare function scanReferencedKeys(cwd: string, roots?: string[]): Promise<ReferencedKey[]>;
-export declare function extractFromSource(source: string, file: string): ReferencedKey[];
+export declare function scanKeys(cwd: string, roots?: string[]): Promise<ScanResult>;
+export declare function extractFromSource(source: string, file: string): ScanResult;

package/dist/compiler/scan-keys.js

@@ -12,9 +12,12 @@ const SKIP_DIRS = new Set([
 ]);
 /**
  * Find `t('key')` / `t.rich('key')` under a known `useT`/`getT` namespace,
- * plus bare `useT('ns')` / `getT('ns')` for namespace awareness.
+ * plus `t.dynamic(..., { from })` declared keys and dynamic `t(var)` markers.
  */
 export async function scanReferencedKeys(cwd, roots = ['app', 'src', 'components']) {
+    return (await scanKeys(cwd, roots)).refs;
+}
+export async function scanKeys(cwd, roots = ['app', 'src', 'components']) {
     const files = [];
     for (const root of roots) {
         const abs = join(cwd, root);
@@ -27,13 +30,17 @@ export async function scanReferencedKeys(cwd, roots = ['app', 'src', 'components
         }
         await walk(abs, files);
     }
-    const out = [];
+    const refs = [];
+    const dynamicNamespaces = new Set();
     for (const file of files) {
         const src = await readFile(file, 'utf8');
         const rel = relative(cwd, file);
-        out.push(...extractFromSource(src, rel));
+        const part = extractFromSource(src, rel);
+        refs.push(...part.refs);
+        for (const ns of part.dynamicNamespaces)
+            dynamicNamespaces.add(ns);
     }
-    return out;
+    return { refs, dynamicNamespaces };
 }
 async function walk(dir, out) {
     const entries = await readdir(dir, { withFileTypes: true });
@@ -57,6 +64,7 @@ function extname(name) {
 }
 export function extractFromSource(source, file) {
     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;
@@ -64,23 +72,65 @@ export function extractFromSource(source, file) {
     while ((m = declRe.exec(source)) !== null) {
         translators.set(m[1], m[3] || '_root');
     }
+    const push = (ns, key, index) => {
+        const fullKey = ns === '_root' || ns === '' ? key : `${ns}.${key}`;
+        out.push({
+            fullKey,
+            namespace: ns || '_root',
+            key,
+            file,
+            line: lineAt(source, 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) {
-            const key = cm[2];
-            const fullKey = ns === '_root' || ns === '' ? key : `${ns}.${key}`;
-            const line = lineAt(source, cm.index);
-            out.push({
-                fullKey,
-                namespace: ns || '_root',
-                key,
-                file,
-                line,
-            });
+            push(ns, cm[2], cm.index);
+        }
+        // t.dynamic(any, { from: ['a', 'b'] })
+        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);
+            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);
+                }
+            }
+            dynamicNamespaces.add(ns || '_root');
+        }
+        // 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) {
+            dynamicNamespaces.add(nm[2] || '_root');
+        }
+        // Non-literal t(var) / t.rich(var) — mark namespace dynamic + harvest nearby string arrays
+        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;
+            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 out;
+    return { refs: out, dynamicNamespaces };
 }
 function lineAt(source, index) {
     let line = 1;

package/dist/compiler/validate/usage.js

@@ -1,5 +1,5 @@
 import { loadLocaleMessages } from '../load-messages.js';
-import { scanReferencedKeys } from '../scan-keys.js';
+import { scanKeys } from '../scan-keys.js';
 function severityFor(level, alwaysError = false) {
     if (alwaysError)
         return 'error';
@@ -7,6 +7,10 @@ function severityFor(level, alwaysError = false) {
         return null;
     return level === 'error' ? 'error' : 'warn';
 }
+function namespaceOf(fullKey) {
+    const i = fullKey.indexOf('.');
+    return i === -1 ? '_root' : fullKey.slice(0, i);
+}
 /** unused + undefined checks against scanned source references. */
 export async function validateUsage(config, cwd) {
     const issues = [];
@@ -20,7 +24,7 @@ export async function validateUsage(config, cwd) {
             defined.add(ns === '_root' ? key : `${ns}.${key}`);
         }
     }
-    const refs = await scanReferencedKeys(cwd);
+    const { refs, dynamicNamespaces } = await scanKeys(cwd);
     const used = new Set();
     for (const ref of refs) {
         used.add(ref.fullKey);
@@ -40,6 +44,9 @@ export async function validateUsage(config, cwd) {
         for (const fullKey of defined) {
             if (used.has(fullKey))
                 continue;
+            // Dynamic t(var) / t.ns / t.dynamic — do not false-flag catalog keys as unused
+            if (dynamicNamespaces.has(namespaceOf(fullKey)))
+                continue;
             issues.push({
                 check: 'unused',
                 severity: unusedSev,

package/package.json

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