next-tongue 0.9.6 → 0.9.7

package/dist/client/index.js

@@ -88,7 +88,7 @@ export function useT(namespace) {
  */
 function createLoaderStubT(locale, ns) {
     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.`);
+        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: [...] }) with an inline array or a same-file const (imported from arrays are not rewritten).`);
     };
     const t = Object.assign((..._args) => fail('t()'), {
         rich: () => fail('t.rich()'),

package/dist/compiler/dynamic-from.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Resolve `t.dynamic(key, { from })` key lists for the call-site loader and
+ * `tongue check` scan. Supports:
+ *   - inline arrays: `{ from: ['a', 'b'] }`
+ *   - same-file const arrays: `const X = ['a', 'b']; { from: X }`
+ *   - Object.values of same-file const objects: `{ from: Object.values(BTN_KEYS) }`
+ *
+ * Imported / computed `from` expressions are not resolved (left as stubs).
+ */
+export declare function extractStringLiterals(body: string): string[];
+/** Take a balanced `[...]` / `{...}` / `(...)` starting at `source[start]`. */
+export declare function takeBalanced(source: string, start: number, open: string, close: string): string | null;
+/**
+ * Resolve keys from a `from` expression text (already sliced out of the call).
+ * Returns null when the expression cannot be resolved statically in-file.
+ */
+export declare function resolveFromKeys(fileSource: string, fromExpr: string): string[] | null;
+export type DynamicCallSite = {
+    /** Start of `t.dynamic` */
+    start: number;
+    /** End after closing `)` */
+    end: number;
+    keyExpr: string;
+    fromExpr: string;
+    valuesExpr: string | null;
+    keys: string[] | null;
+};
+/**
+ * Find `varName.dynamic(...)` call sites and resolve their `from` keys.
+ */
+export declare function findDynamicCalls(source: string, varName: string): DynamicCallSite[];

package/dist/compiler/dynamic-from.js

@@ -0,0 +1,240 @@
+/**
+ * Resolve `t.dynamic(key, { from })` key lists for the call-site loader and
+ * `tongue check` scan. Supports:
+ *   - inline arrays: `{ from: ['a', 'b'] }`
+ *   - same-file const arrays: `const X = ['a', 'b']; { from: X }`
+ *   - Object.values of same-file const objects: `{ from: Object.values(BTN_KEYS) }`
+ *
+ * Imported / computed `from` expressions are not resolved (left as stubs).
+ */
+export function extractStringLiterals(body) {
+    return [...body.matchAll(/['"]([^'"]+)['"]/g)].map((m) => m[1]);
+}
+/** Take a balanced `[...]` / `{...}` / `(...)` starting at `source[start]`. */
+export function takeBalanced(source, start, open, close) {
+    if (source[start] !== open)
+        return null;
+    let depth = 0;
+    let inStr = null;
+    let escape = false;
+    for (let i = start; i < source.length; i++) {
+        const c = source[i];
+        if (inStr) {
+            if (escape) {
+                escape = false;
+                continue;
+            }
+            if (c === '\\' && inStr !== '`') {
+                escape = true;
+                continue;
+            }
+            if (c === inStr)
+                inStr = null;
+            continue;
+        }
+        if (c === '"' || c === "'" || c === '`') {
+            inStr = c;
+            continue;
+        }
+        if (c === open)
+            depth++;
+        else if (c === close) {
+            depth--;
+            if (depth === 0)
+                return source.slice(start, i + 1);
+        }
+    }
+    return null;
+}
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** Index of `ident`'s `const|let|var` initializer expression, or -1. */
+function findDeclInit(source, ident) {
+    const re = new RegExp(`(?:const|let|var)\\s+${escapeRegExp(ident)}\\s*=\\s*`, 'g');
+    const m = re.exec(source);
+    return m ? m.index + m[0].length : -1;
+}
+function skipWs(source, i) {
+    while (/\s/.test(source[i] ?? ''))
+        i++;
+    return i;
+}
+function resolveConstArrayKeys(source, ident) {
+    const init = findDeclInit(source, ident);
+    if (init < 0)
+        return null;
+    const arr = takeBalanced(source, skipWs(source, init), '[', ']');
+    if (!arr)
+        return null;
+    return extractStringLiterals(arr.slice(1, -1));
+}
+function resolveObjectValueKeys(source, ident) {
+    const init = findDeclInit(source, ident);
+    if (init < 0)
+        return null;
+    // Type assertions (`as const`) sit after the literal; object is first.
+    const obj = takeBalanced(source, skipWs(source, init), '{', '}');
+    if (!obj)
+        return null;
+    return [...obj.matchAll(/:\s*['"]([^'"]+)['"]/g)].map((m) => m[1]);
+}
+/**
+ * Resolve keys from a `from` expression text (already sliced out of the call).
+ * Returns null when the expression cannot be resolved statically in-file.
+ */
+export function resolveFromKeys(fileSource, fromExpr) {
+    const trimmed = fromExpr.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.startsWith('[')) {
+        const arr = takeBalanced(trimmed, 0, '[', ']');
+        if (!arr)
+            return null;
+        return extractStringLiterals(arr.slice(1, -1));
+    }
+    const ov = /^Object\.values\(\s*([A-Za-z_$][\w$]*)\s*\)$/.exec(trimmed);
+    if (ov) {
+        const keys = resolveObjectValueKeys(fileSource, ov[1]);
+        return keys && keys.length > 0 ? keys : null;
+    }
+    if (/^[A-Za-z_$][\w$]*$/.test(trimmed)) {
+        const keys = resolveConstArrayKeys(fileSource, trimmed);
+        return keys && keys.length > 0 ? keys : null;
+    }
+    return null;
+}
+/**
+ * Find `varName.dynamic(...)` call sites and resolve their `from` keys.
+ */
+export function findDynamicCalls(source, varName) {
+    const re = new RegExp(`\\b${escapeRegExp(varName)}\\.dynamic\\s*\\(`, 'g');
+    const out = [];
+    let m;
+    while ((m = re.exec(source)) !== null) {
+        const openParen = m.index + m[0].length - 1;
+        const parsed = parseDynamicArgs(source, openParen);
+        if (!parsed)
+            continue;
+        const keys = resolveFromKeys(source, parsed.fromExpr);
+        out.push({
+            start: m.index,
+            end: parsed.closeParen + 1,
+            keyExpr: parsed.keyExpr,
+            fromExpr: parsed.fromExpr,
+            valuesExpr: parsed.valuesExpr,
+            keys,
+        });
+    }
+    return out;
+}
+function parseDynamicArgs(source, openParen) {
+    let i = openParen + 1;
+    while (/\s/.test(source[i] ?? ''))
+        i++;
+    const keyStart = i;
+    i = scanArgEnd(source, i);
+    if (i < 0 || source[i] !== ',')
+        return null;
+    const keyExpr = source.slice(keyStart, i).trim();
+    i++;
+    while (/\s/.test(source[i] ?? ''))
+        i++;
+    if (source[i] !== '{')
+        return null;
+    const opts = takeBalanced(source, i, '{', '}');
+    if (!opts)
+        return null;
+    const optsEnd = i + opts.length;
+    const fromExpr = extractFromProp(opts);
+    if (fromExpr == null)
+        return null;
+    i = optsEnd;
+    while (/\s/.test(source[i] ?? ''))
+        i++;
+    let valuesExpr = null;
+    if (source[i] === ',') {
+        i++;
+        while (/\s/.test(source[i] ?? ''))
+            i++;
+        const valuesStart = i;
+        i = scanArgEnd(source, i);
+        if (i < 0)
+            return null;
+        valuesExpr = source.slice(valuesStart, i).trim() || null;
+    }
+    while (/\s/.test(source[i] ?? ''))
+        i++;
+    if (source[i] !== ')')
+        return null;
+    return { keyExpr, fromExpr, valuesExpr, closeParen: i };
+}
+/** Scan to next top-level `,` or `)` (not inside strings/brackets). */
+function scanArgEnd(source, start) {
+    let depthParen = 0;
+    let depthBracket = 0;
+    let depthBrace = 0;
+    let inStr = null;
+    let escape = false;
+    for (let i = start; i < source.length; i++) {
+        const c = source[i];
+        if (inStr) {
+            if (escape) {
+                escape = false;
+                continue;
+            }
+            if (c === '\\' && inStr !== '`') {
+                escape = true;
+                continue;
+            }
+            if (c === inStr)
+                inStr = null;
+            continue;
+        }
+        if (c === '"' || c === "'" || c === '`') {
+            inStr = c;
+            continue;
+        }
+        if (c === '(')
+            depthParen++;
+        else if (c === ')') {
+            if (depthParen === 0 && depthBracket === 0 && depthBrace === 0)
+                return i;
+            depthParen--;
+        }
+        else if (c === '[')
+            depthBracket++;
+        else if (c === ']')
+            depthBracket--;
+        else if (c === '{')
+            depthBrace++;
+        else if (c === '}')
+            depthBrace--;
+        else if (c === ',' &&
+            depthParen === 0 &&
+            depthBracket === 0 &&
+            depthBrace === 0) {
+            return i;
+        }
+    }
+    return -1;
+}
+function extractFromProp(optsLiteral) {
+    // optsLiteral includes surrounding braces
+    const inner = optsLiteral.slice(1, -1);
+    const fromIdx = /\bfrom\s*:/.exec(inner);
+    if (!fromIdx)
+        return null;
+    let i = fromIdx.index + fromIdx[0].length;
+    while (/\s/.test(inner[i] ?? ''))
+        i++;
+    if (inner[i] === '[') {
+        const arr = takeBalanced(inner, i, '[', ']');
+        return arr;
+    }
+    const ov = /^Object\.values\(\s*[A-Za-z_$][\w$]*\s*\)/.exec(inner.slice(i));
+    if (ov)
+        return ov[0];
+    const id = /^[A-Za-z_$][\w$]*/.exec(inner.slice(i));
+    return id ? id[0] : null;
+}

package/dist/compiler/scan-keys.js

@@ -1,5 +1,6 @@
 import { readdir, readFile, stat } from 'node:fs/promises';
 import { join, relative } from 'node:path';
+import { findDynamicCalls } from './dynamic-from.js';
 const SOURCE_EXT = new Set(['.ts', '.tsx', '.js', '.jsx', '.mdx']);
 const SKIP_DIRS = new Set([
     'node_modules',
@@ -152,16 +153,11 @@ export function extractFromSource(source, file) {
         while ((cm = callRe.exec(code)) !== null) {
             push(ns, cm[2], cm.index);
         }
-        // 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(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) {
-                    push(ns, raw.slice(1, -1), dm.index);
+        // t.dynamic(any, { from }) — only resolvable `from` keys become refs
+        for (const call of findDynamicCalls(code, varName)) {
+            if (call.keys) {
+                for (const key of call.keys) {
+                    push(ns, key, call.start);
                 }
             }
             dynamicNamespaces.add(ns || '_root');

package/dist/next/loader.d.ts

@@ -6,7 +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.
+ * Also rewrites `t.dynamic(key, { from })` to a map of those imports when `from`
+ * is an inline array, a same-file const array, or `Object.values(sameFileConst)`.
  *
  * Escape analysis: if `t` is passed around, falls back to namespace import + warning.
  */

package/dist/next/loader.js

@@ -6,10 +6,12 @@
  *   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.
+ * Also rewrites `t.dynamic(key, { from })` to a map of those imports when `from`
+ * is an inline array, a same-file const array, or `Object.values(sameFileConst)`.
  *
  * Escape analysis: if `t` is passed around, falls back to namespace import + warning.
  */
+import { findDynamicCalls } from '../compiler/dynamic-from.js';
 const USE_T_DECL = /(?:const|let|var)\s+(\w+)\s*=\s*useT\s*\(\s*(['"])([^'"]*)\2\s*\)/g;
 export function transformCallSites(source, resourcePath, _options = {}) {
     const warnings = [];
@@ -44,16 +46,11 @@ export function transformCallSites(source, resourcePath, _options = {}) {
             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)
+        // t.dynamic(expr, { from }, values?) — collect resolvable keys
+        for (const call of findDynamicCalls(withoutDirs, varName)) {
+            if (!call.keys)
                 continue;
-            const keys = [...fromMatch[1].matchAll(/['"]([^'"]+)['"]/g)].map((x) => x[1]);
-            for (const key of keys) {
+            for (const key of call.keys) {
                 const ident = safeImportIdent(ns, key);
                 imports.set(`${ns}:${key}`, { ns, key, ident });
             }
@@ -72,13 +69,14 @@ 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();`);
-    // Replace t.dynamic(expr, { from: [...] }, values?)
+    // 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 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 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];
+            const keys = call.keys;
             const mapEntries = keys
                 .map((key) => {
                 const ident = safeImportIdent(ns, key);
@@ -86,11 +84,12 @@ export function transformCallSites(source, resourcePath, _options = {}) {
                 return `${JSON.stringify(key)}: ${ident}`;
             })
                 .join(', ');
-            const valuesArg = values != null && String(values).trim() !== ''
-                ? `, ${String(values).trim()}`
+            const valuesArg = call.valuesExpr != null && call.valuesExpr.trim() !== ''
+                ? `, ${call.valuesExpr.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} })`;
-        });
+            const replacement = `((__tongue_dyn) => { const __tongue_fn = __tongue_dyn[${call.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} })`;
+            code = code.slice(0, call.start) + replacement + code.slice(call.end);
+        }
     }
     // Replace t('key', values) / t.rich('key', values) with per-key calls
     for (const [varName, ns] of translators) {

package/package.json

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