fimo 0.7.0-experimental.10 → 0.7.0-experimental.11

package/dist/cli/bundle.json

@@ -1,7 +1,7 @@
 {
   "bundled": true,
   "bundler": "esbuild",
-  "bundledAt": "2026-07-23T12:45:08.799Z",
+  "bundledAt": "2026-07-23T13:02:24.798Z",
   "cliVersion": "0.6.0",
   "external": [
     "oxc-parser",

package/dist/cli/index.js

@@ -46647,6 +46647,60 @@ var init_staged_labels = __esm({
 });
 
 // src/scripts/i18n-namespace.ts
+function translationCallNamespace(node) {
+  if (node?.type !== "CallExpression" || node.callee?.type !== "Identifier") {
+    return null;
+  }
+  if (node.callee.name !== "useTranslations" && node.callee.name !== "getTranslations") {
+    return null;
+  }
+  const arg = node.arguments?.[0];
+  if (!arg) {
+    return "";
+  }
+  if (arg.type === "Literal" && typeof arg.value === "string") {
+    return arg.value;
+  }
+  if (arg.type === "ObjectExpression") {
+    for (const prop2 of arg.properties ?? []) {
+      const keyName = prop2?.key?.name ?? prop2?.key?.value;
+      if (keyName === "namespace" && prop2.value?.type === "Literal" && typeof prop2.value.value === "string") {
+        return prop2.value.value;
+      }
+    }
+  }
+  return "";
+}
+function markParamBindings(node, bindings) {
+  if (!node) {
+    return;
+  }
+  switch (node.type) {
+    case "Identifier":
+      if (!bindings.has(node.name)) {
+        bindings.set(node.name, null);
+      }
+      break;
+    case "AssignmentPattern":
+      markParamBindings(node.left, bindings);
+      break;
+    case "RestElement":
+      markParamBindings(node.argument, bindings);
+      break;
+    case "ArrayPattern":
+      for (const element of node.elements ?? []) {
+        markParamBindings(element, bindings);
+      }
+      break;
+    case "ObjectPattern":
+      for (const prop2 of node.properties ?? []) {
+        markParamBindings(prop2.type === "RestElement" ? prop2.argument : prop2.value, bindings);
+      }
+      break;
+    default:
+      break;
+  }
+}
 function collectScopedBindings(fnNode) {
   const bindings = /* @__PURE__ */ new Map();
   const body = fnNode.body;
@@ -46656,32 +46710,56 @@ function collectScopedBindings(fnNode) {
       continue;
     }
     for (const decl of stmt.declarations ?? []) {
-      if (decl?.id?.type !== "Identifier") {
+      const init = unwrapAwait(decl?.init);
+      if (decl?.id?.type === "Identifier") {
+        const namespace = translationCallNamespace(init);
+        if (namespace !== null) {
+          bindings.set(decl.id.name, namespace);
+        }
         continue;
       }
-      const init = decl.init?.type === "AwaitExpression" ? decl.init.argument : decl.init;
-      if (init?.type === "CallExpression" && init.callee?.type === "Identifier" && (init.callee.name === "useTranslations" || init.callee.name === "getTranslations")) {
-        const nsArg = init.arguments?.[0];
-        const namespace = nsArg?.type === "Literal" && typeof nsArg.value === "string" ? nsArg.value : "";
-        bindings.set(decl.id.name, namespace);
+      if (decl?.id?.type === "ArrayPattern") {
+        const source = init?.type === "CallExpression" && init.callee?.type === "Identifier" && init.callee.name === "use" ? unwrapAwait(init.arguments?.[0]) : init;
+        const promiseAll = source?.type === "CallExpression" && source.callee?.type === "MemberExpression" && source.callee.object?.name === "Promise" && source.callee.property?.name === "all";
+        const elements = promiseAll ? source.arguments?.[0]?.type === "ArrayExpression" ? source.arguments[0].elements : null : source?.type === "ArrayExpression" ? source.elements : null;
+        if (elements) {
+          decl.id.elements?.forEach((el, index2) => {
+            if (el?.type !== "Identifier") {
+              return;
+            }
+            const namespace = translationCallNamespace(unwrapAwait(elements[index2]));
+            if (namespace !== null) {
+              bindings.set(el.name, namespace);
+            }
+          });
+        }
       }
     }
   }
+  for (const param of fnNode.params ?? []) {
+    markParamBindings(param, bindings);
+  }
   return bindings;
 }
 function resolveScopedKey(calleeName, leafKey, scopes) {
   for (let i = scopes.length - 1; i >= 0; i -= 1) {
     if (scopes[i].has(calleeName)) {
       const namespace = scopes[i].get(calleeName);
-      return { key: namespace ? `${namespace}.${leafKey}` : leafKey, scoped: true };
+      if (namespace === null || namespace === void 0) {
+        return { key: leafKey, scoped: false, unresolvable: true };
+      }
+      return { key: namespace ? `${namespace}.${leafKey}` : leafKey, scoped: true, unresolvable: false };
     }
   }
-  return { key: leafKey, scoped: false };
+  return { key: leafKey, scoped: false, unresolvable: false };
 }
-var isFunctionLike;
+var isFunctionLike, unwrapAwait;
 var init_i18n_namespace = __esm({
   "src/scripts/i18n-namespace.ts"() {
     isFunctionLike = /* @__PURE__ */ __name((node) => node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression", "isFunctionLike");
+    unwrapAwait = /* @__PURE__ */ __name((node) => node?.type === "AwaitExpression" ? node.argument : node, "unwrapAwait");
+    __name(translationCallNamespace, "translationCallNamespace");
+    __name(markParamBindings, "markParamBindings");
     __name(collectScopedBindings, "collectScopedBindings");
     __name(resolveScopedKey, "resolveScopedKey");
   }
@@ -49534,7 +49612,10 @@ function scanWrappableFile(filePath, code2, relPath, opts = {}) {
         wrapped += 1;
         const firstArg = node.arguments?.[0];
         if (firstArg?.type === "Literal" && typeof firstArg.value === "string") {
-          wrappedIds.labels.push(resolveScopedKey(node.callee.name, firstArg.value, childScopes).key);
+          const resolved = resolveScopedKey(node.callee.name, firstArg.value, childScopes);
+          if (!resolved.unresolvable) {
+            wrappedIds.labels.push(resolved.key);
+          }
         }
       }
     }
@@ -106835,8 +106916,8 @@ function extractFromFile(filePath) {
         const name = node.callee.name;
         const firstArg = (node.arguments ?? [])[0];
         if (firstArg?.type === "Literal" && typeof firstArg.value === "string") {
-          const { key, scoped } = resolveScopedKey(name, firstArg.value, childScopes);
-          if (scoped || name === "t") {
+          const { key, scoped, unresolvable } = resolveScopedKey(name, firstArg.value, childScopes);
+          if (!unresolvable && (scoped || name === "t")) {
             declarations.push({ key, file: filePath });
           }
         }

package/dist/scripts/extract-translations.js

@@ -46,10 +46,10 @@ function extractFromFile(filePath) {
                 const name = node.callee.name;
                 const firstArg = (node.arguments ?? [])[0];
                 if (firstArg?.type === 'Literal' && typeof firstArg.value === 'string') {
-                    const { key, scoped } = resolveScopedKey(name, firstArg.value, childScopes);
-                    // A namespace-scoped var (any name) OR a bare Fimo `t(...)` — record the
-                    // resolved key (scoped prepends the namespace; unscoped `t` is the leaf).
-                    if (scoped || name === 't') {
+                    const { key, scoped, unresolvable } = resolveScopedKey(name, firstArg.value, childScopes);
+                    // A namespace-scoped var (any name) OR a bare Fimo `t(...)`. A passed-in
+                    // param `t` is unresolvable (the caller owns the namespace) — skip it.
+                    if (!unresolvable && (scoped || name === 't')) {
                         declarations.push({ key, file: filePath });
                     }
                 }

package/dist/scripts/extract-translations.test.js

@@ -63,4 +63,42 @@ export default async function Page() {
         });
         expect(keysOf(cwd)).toEqual(['home.title']);
     });
+    it('resolves the object-arg namespace: getTranslations({ namespace })', () => {
+        const cwd = project({
+            'src/meta.tsx': `import { getTranslations } from 'next-intl/server';
+export async function generateMetadata({ params }) {
+  const t = await getTranslations({ locale: params.locale, namespace: 'seo' });
+  return { title: t('metaTitle'), keywords: t('keywords') };
+}`,
+        });
+        expect(keysOf(cwd)).toEqual(['seo.keywords', 'seo.metaTitle']);
+    });
+    it('resolves a t destructured from Promise.all (with or without a use() wrapper)', () => {
+        const cwd = project({
+            'src/a.tsx': `import { getTranslations } from 'next-intl/server';
+export async function A() {
+  const [data, t] = await Promise.all([fetchData(), getTranslations('cms')]);
+  return <p>{t('compare')}</p>;
+}`,
+            'src/b.tsx': `import { use } from 'react';
+import { getTranslations } from 'next-intl/server';
+export function B() {
+  const [data, t] = use(Promise.all([fetchData(), getTranslations('cms')]));
+  return <p>{t('disclaimer')}</p>;
+}`,
+        });
+        expect(keysOf(cwd)).toEqual(['cms.compare', 'cms.disclaimer']);
+    });
+    it('skips a t passed in as a parameter — plain or destructured (caller owns the namespace)', () => {
+        const cwd = project({
+            'src/defaults.tsx': `export function getDefaults(siteUrl, t) {
+  return { title: t('metaTitle'), keywords: t('keywords') };
+}`,
+            'src/grid.tsx': `export function Grid({ t, items }) {
+  return <button>{t('loadMore')}</button>;
+}`,
+        });
+        // Unresolvable param keys are dropped, not recorded as bare leaves.
+        expect(keysOf(cwd)).toEqual([]);
+    });
 });

package/dist/scripts/i18n-namespace.d.ts

@@ -10,16 +10,18 @@
  * with no binding (Fimo's own label call) keeps its key unchanged.
  */
 export declare const isFunctionLike: (node: any) => boolean;
-/** Collect `useTranslations`/`getTranslations` bindings declared in a function's
- *  direct body: variable name → namespace (`""` for root scope). */
-export declare function collectScopedBindings(fnNode: any): Map<string, string>;
+export declare function collectScopedBindings(fnNode: any): Map<string, string | null>;
 /**
  * Resolve a `<name>("leaf")` call to its full key given the scope stack
- * (innermost first). Returns `{ key, scoped }`: `scoped` is true when the callee
- * is a resolved `useTranslations` binding (so the caller can decide whether an
- * unbound name still counts). The namespace is prepended unless it is root (`""`).
+ * (innermost first).
+ * - `scoped`: the callee is a resolved `useTranslations` binding — namespace
+ *   prepended (unless root `""`).
+ * - `unresolvable`: the callee is a passed-in parameter — its namespace lives in
+ *   the caller and cannot be known here, so the caller should count the call as
+ *   covered but NOT demand the (bare) key.
  */
-export declare function resolveScopedKey(calleeName: string, leafKey: string, scopes: Array<Map<string, string>>): {
+export declare function resolveScopedKey(calleeName: string, leafKey: string, scopes: Array<Map<string, string | null>>): {
     key: string;
     scoped: boolean;
+    unresolvable: boolean;
 };

package/dist/scripts/i18n-namespace.js

@@ -12,6 +12,69 @@
 export const isFunctionLike = (node) => node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression';
 /** Collect `useTranslations`/`getTranslations` bindings declared in a function's
  *  direct body: variable name → namespace (`""` for root scope). */
+const unwrapAwait = (node) => (node?.type === 'AwaitExpression' ? node.argument : node);
+/**
+ * The namespace of a `useTranslations`/`getTranslations` call, or null if the
+ * node is not such a call. Handles the string arg (`getTranslations("seo")`),
+ * the object arg (`getTranslations({ locale, namespace: "seo" })`), and no arg
+ * (root scope → `""`). A dynamic namespace resolves to `""` (best effort).
+ */
+function translationCallNamespace(node) {
+    if (node?.type !== 'CallExpression' || node.callee?.type !== 'Identifier') {
+        return null;
+    }
+    if (node.callee.name !== 'useTranslations' && node.callee.name !== 'getTranslations') {
+        return null;
+    }
+    const arg = node.arguments?.[0];
+    if (!arg) {
+        return '';
+    }
+    if (arg.type === 'Literal' && typeof arg.value === 'string') {
+        return arg.value;
+    }
+    if (arg.type === 'ObjectExpression') {
+        for (const prop of arg.properties ?? []) {
+            const keyName = prop?.key?.name ?? prop?.key?.value;
+            if (keyName === 'namespace' && prop.value?.type === 'Literal' && typeof prop.value.value === 'string') {
+                return prop.value.value;
+            }
+        }
+    }
+    return '';
+}
+/** Mark every identifier bound by a parameter pattern (plain, defaulted, or
+ *  destructured — `t`, `t = x`, `{ t }`, `[t]`) as unresolvable (null). */
+function markParamBindings(node, bindings) {
+    if (!node) {
+        return;
+    }
+    switch (node.type) {
+        case 'Identifier':
+            if (!bindings.has(node.name)) {
+                bindings.set(node.name, null);
+            }
+            break;
+        case 'AssignmentPattern':
+            markParamBindings(node.left, bindings);
+            break;
+        case 'RestElement':
+            markParamBindings(node.argument, bindings);
+            break;
+        case 'ArrayPattern':
+            for (const element of node.elements ?? []) {
+                markParamBindings(element, bindings);
+            }
+            break;
+        case 'ObjectPattern':
+            for (const prop of node.properties ?? []) {
+                markParamBindings(prop.type === 'RestElement' ? prop.argument : prop.value, bindings);
+            }
+            break;
+        default:
+            break;
+    }
+}
 export function collectScopedBindings(fnNode) {
     const bindings = new Map();
     const body = fnNode.body;
@@ -21,33 +84,72 @@ export function collectScopedBindings(fnNode) {
             continue;
         }
         for (const decl of stmt.declarations ?? []) {
-            if (decl?.id?.type !== 'Identifier') {
+            const init = unwrapAwait(decl?.init);
+            // `const t = [await] useTranslations/getTranslations(...)`
+            if (decl?.id?.type === 'Identifier') {
+                const namespace = translationCallNamespace(init);
+                if (namespace !== null) {
+                    bindings.set(decl.id.name, namespace);
+                }
                 continue;
             }
-            const init = decl.init?.type === 'AwaitExpression' ? decl.init.argument : decl.init;
-            if (init?.type === 'CallExpression' &&
-                init.callee?.type === 'Identifier' &&
-                (init.callee.name === 'useTranslations' || init.callee.name === 'getTranslations')) {
-                const nsArg = init.arguments?.[0];
-                const namespace = nsArg?.type === 'Literal' && typeof nsArg.value === 'string' ? nsArg.value : '';
-                bindings.set(decl.id.name, namespace);
+            // `const [a, t] = await Promise.all([...])` or `= use(Promise.all([...]))`
+            if (decl?.id?.type === 'ArrayPattern') {
+                // Unwrap React's `use()` wrapper around the promise.
+                const source = init?.type === 'CallExpression' && init.callee?.type === 'Identifier' && init.callee.name === 'use'
+                    ? unwrapAwait(init.arguments?.[0])
+                    : init;
+                const promiseAll = source?.type === 'CallExpression' &&
+                    source.callee?.type === 'MemberExpression' &&
+                    source.callee.object?.name === 'Promise' &&
+                    source.callee.property?.name === 'all';
+                const elements = promiseAll
+                    ? source.arguments?.[0]?.type === 'ArrayExpression'
+                        ? source.arguments[0].elements
+                        : null
+                    : source?.type === 'ArrayExpression'
+                        ? source.elements
+                        : null;
+                if (elements) {
+                    decl.id.elements?.forEach((el, index) => {
+                        if (el?.type !== 'Identifier') {
+                            return;
+                        }
+                        const namespace = translationCallNamespace(unwrapAwait(elements[index]));
+                        if (namespace !== null) {
+                            bindings.set(el.name, namespace);
+                        }
+                    });
+                }
             }
         }
     }
+    // Function parameters are bound by the CALLER: a `t` passed in carries the
+    // caller's namespace, unknowable here. Mark them null so their t() calls are
+    // counted as covered but never demanded by the seeding gate as a bare leaf.
+    for (const param of fnNode.params ?? []) {
+        markParamBindings(param, bindings);
+    }
     return bindings;
 }
 /**
  * Resolve a `<name>("leaf")` call to its full key given the scope stack
- * (innermost first). Returns `{ key, scoped }`: `scoped` is true when the callee
- * is a resolved `useTranslations` binding (so the caller can decide whether an
- * unbound name still counts). The namespace is prepended unless it is root (`""`).
+ * (innermost first).
+ * - `scoped`: the callee is a resolved `useTranslations` binding — namespace
+ *   prepended (unless root `""`).
+ * - `unresolvable`: the callee is a passed-in parameter — its namespace lives in
+ *   the caller and cannot be known here, so the caller should count the call as
+ *   covered but NOT demand the (bare) key.
  */
 export function resolveScopedKey(calleeName, leafKey, scopes) {
     for (let i = scopes.length - 1; i >= 0; i -= 1) {
         if (scopes[i].has(calleeName)) {
             const namespace = scopes[i].get(calleeName);
-            return { key: namespace ? `${namespace}.${leafKey}` : leafKey, scoped: true };
+            if (namespace === null || namespace === undefined) {
+                return { key: leafKey, scoped: false, unresolvable: true };
+            }
+            return { key: namespace ? `${namespace}.${leafKey}` : leafKey, scoped: true, unresolvable: false };
         }
     }
-    return { key: leafKey, scoped: false };
+    return { key: leafKey, scoped: false, unresolvable: false };
 }

package/dist/scripts/scan-wrappable.js

@@ -578,8 +578,13 @@ export function scanWrappableFile(filePath, code, relPath, opts = {}) {
                 const firstArg = node.arguments?.[0];
                 if (firstArg?.type === 'Literal' && typeof firstArg.value === 'string') {
                     // Resolve the next-intl namespace so the recorded key matches the
-                    // ingested (namespaced) label in the DB, not the bare leaf.
-                    wrappedIds.labels.push(resolveScopedKey(node.callee.name, firstArg.value, childScopes).key);
+                    // ingested (namespaced) label in the DB. A passed-in param `t` is
+                    // unresolvable (the caller owns the namespace) — the call still counts
+                    // as wrapped, but we do not demand its bare key from the seeding gate.
+                    const resolved = resolveScopedKey(node.callee.name, firstArg.value, childScopes);
+                    if (!resolved.unresolvable) {
+                        wrappedIds.labels.push(resolved.key);
+                    }
                 }
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fimo",
-  "version": "0.7.0-experimental.10",
+  "version": "0.7.0-experimental.11",
   "description": "Fimo CLI - create, deploy, and manage Fimo projects",
   "bin": {
     "fimo": "dist/cli/index.js"

package/templates/react-router/package.json

@@ -21,7 +21,7 @@
     "cmdk": "^1.1.1",
     "date-fns": "^4.1.0",
     "embla-carousel-react": "^8.6.0",
-    "fimo": "0.7.0-experimental.10",
+    "fimo": "0.7.0-experimental.11",
     "input-otp": "^1.4.2",
     "isbot": "^5",
     "lucide-react": "^0.577.0",