fimo 0.2.4 → 0.2.5-experimental.1782327181771

package/assets/agent-templates/content-translator/scripts/write-locale-files.ts

@@ -1,66 +0,0 @@
-/**
- * Tool: write-locale-files
- *
- * For locale-keyed JSON files in `src/locales/<locale>.json`, fill in
- * missing keys from the default-locale file using the configured
- * translation provider. Run after translate-entries when projects mix
- * CMS-driven copy with hardcoded i18n strings.
- */
-
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-
-interface Catalog {
-  [key: string]: string;
-}
-
-async function readCatalog(file: string): Promise<Catalog> {
-  try {
-    const text = await fs.readFile(file, 'utf8');
-    return JSON.parse(text) as Catalog;
-  } catch {
-    return {};
-  }
-}
-
-async function writeCatalog(file: string, catalog: Catalog): Promise<void> {
-  await fs.writeFile(file, JSON.stringify(catalog, null, 2) + '\n', 'utf8');
-}
-
-async function translate(text: string, _to: string): Promise<string> {
-  // Stub — provider-specific call.
-  return text;
-}
-
-async function main(): Promise<void> {
-  const defaultLocale = process.env.FIMO_DEFAULT_LOCALE ?? 'en';
-  const targetLocales = (process.env.FIMO_TARGET_LOCALES ?? '').split(',').filter(Boolean);
-  const localesDir = process.env.FIMO_LOCALES_DIR ?? 'src/locales';
-
-  const defaultFile = path.join(localesDir, `${defaultLocale}.json`);
-  const defaultCatalog = await readCatalog(defaultFile);
-
-  for (const target of targetLocales) {
-    const targetFile = path.join(localesDir, `${target}.json`);
-    const targetCatalog = await readCatalog(targetFile);
-    let dirty = false;
-
-    for (const [key, sourceValue] of Object.entries(defaultCatalog)) {
-      if (targetCatalog[key]) {
-        continue;
-      }
-      targetCatalog[key] = await translate(sourceValue, target);
-      dirty = true;
-    }
-
-    if (dirty) {
-      await writeCatalog(targetFile, targetCatalog);
-      console.log(`Wrote ${targetFile}`);
-    }
-  }
-}
-
-main().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});

package/dist/scripts/inject-translations.d.ts

@@ -1,6 +0,0 @@
-export interface InjectTranslationsResult {
-    updated: number;
-}
-export declare function injectTranslations(options?: {
-    cwd?: string;
-}): InjectTranslationsResult;

package/dist/scripts/inject-translations.js

@@ -1,168 +0,0 @@
-/**
- * Inject translation values from translations/en.json back into code.
- *
- * Reads `translations/en.json` (treated as authoritative input — typically
- * written by the backend after a dashboard editor edits an English string)
- * and rewrites the second argument of every matching `t('key', 'default')`
- * call in `src/` to match. Idempotent.
- *
- * Exposed as `fimo scripts inject-translations` (hidden namespace). The
- * backend's bidirectional-sync flow will eventually invoke this command in
- * the sandbox instead of the legacy `node .fimo/i18n/scripts/...` path.
- */
-import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { parseSync } from 'oxc-parser';
-function findReactFiles(dir, files = []) {
-    if (!existsSync(dir)) {
-        return files;
-    }
-    const entries = readdirSync(dir);
-    for (const entry of entries) {
-        const fullPath = join(dir, entry);
-        const stat = statSync(fullPath);
-        if (stat.isDirectory()) {
-            if (entry === 'ui' || entry === 'node_modules') {
-                continue;
-            }
-            findReactFiles(fullPath, files);
-        }
-        else if (/\.(ts|tsx|js|jsx)$/.test(entry)) {
-            files.push(fullPath);
-        }
-    }
-    return files;
-}
-function findTCalls(filePath, code) {
-    const locations = [];
-    try {
-        const result = parseSync(filePath, code);
-        const ast = result.program;
-        function visit(node) {
-            if (!node || typeof node !== 'object') {
-                return;
-            }
-            if (node.type === 'CallExpression') {
-                const callee = node.callee;
-                if (callee?.type === 'Identifier' && callee?.name === 't') {
-                    const args = node.arguments || [];
-                    const firstArg = args[0];
-                    if (firstArg?.type === 'Literal' && typeof firstArg.value === 'string') {
-                        const key = firstArg.value;
-                        const secondArg = args[1];
-                        if (secondArg?.type === 'Literal' && typeof secondArg.value === 'string') {
-                            locations.push({
-                                file: filePath,
-                                key,
-                                currentDefault: secondArg.value,
-                                secondArgStart: secondArg.start,
-                                secondArgEnd: secondArg.end,
-                                hasSecondArg: true,
-                                firstArgEnd: firstArg.end,
-                            });
-                        }
-                        else if (!secondArg) {
-                            locations.push({
-                                file: filePath,
-                                key,
-                                currentDefault: '',
-                                secondArgStart: 0,
-                                secondArgEnd: 0,
-                                hasSecondArg: false,
-                                firstArgEnd: firstArg.end,
-                            });
-                        }
-                    }
-                }
-            }
-            for (const k of Object.keys(node)) {
-                const child = node[k];
-                if (Array.isArray(child)) {
-                    for (const item of child) {
-                        visit(item);
-                    }
-                }
-                else if (typeof child === 'object' && child !== null) {
-                    visit(child);
-                }
-            }
-        }
-        visit(ast);
-    }
-    catch (error) {
-        console.error(`Failed to parse ${filePath}:`, error);
-    }
-    return locations;
-}
-function escapeString(str) {
-    return str
-        .replace(/\\/g, '\\\\')
-        .replace(/'/g, "\\'")
-        .replace(/\n/g, '\\n')
-        .replace(/\r/g, '\\r')
-        .replace(/\t/g, '\\t');
-}
-export function injectTranslations(options = {}) {
-    const cwd = options.cwd ?? process.cwd();
-    const translationsFile = join(cwd, 'translations', 'en.json');
-    if (!existsSync(translationsFile)) {
-        return { updated: 0 };
-    }
-    let translations;
-    try {
-        translations = JSON.parse(readFileSync(translationsFile, 'utf-8'));
-    }
-    catch {
-        throw new Error(`Failed to parse ${translationsFile}`);
-    }
-    const srcDir = join(cwd, 'src');
-    const files = findReactFiles(srcDir);
-    const fileContents = new Map();
-    const fileLocations = new Map();
-    for (const file of files) {
-        const code = readFileSync(file, 'utf-8');
-        fileContents.set(file, code);
-        const locations = findTCalls(file, code);
-        if (locations.length > 0) {
-            fileLocations.set(file, locations);
-        }
-    }
-    let totalUpdates = 0;
-    for (const [file, locations] of fileLocations) {
-        let code = fileContents.get(file);
-        let offset = 0;
-        let fileModified = false;
-        const sortedLocations = [...locations].sort((a, b) => a.secondArgStart - b.secondArgStart);
-        for (const loc of sortedLocations) {
-            const expectedValue = translations[loc.key];
-            if (expectedValue === undefined) {
-                continue;
-            }
-            if (loc.hasSecondArg) {
-                if (loc.currentDefault !== expectedValue) {
-                    const newLiteral = `'${escapeString(expectedValue)}'`;
-                    const before = code.slice(0, loc.secondArgStart + offset);
-                    const after = code.slice(loc.secondArgEnd + offset);
-                    code = before + newLiteral + after;
-                    offset += newLiteral.length - (loc.secondArgEnd - loc.secondArgStart);
-                    fileModified = true;
-                    totalUpdates++;
-                }
-            }
-            else {
-                if (expectedValue !== '') {
-                    const newArg = `, '${escapeString(expectedValue)}'`;
-                    const insertPos = loc.firstArgEnd + offset;
-                    code = code.slice(0, insertPos) + newArg + code.slice(insertPos);
-                    offset += newArg.length;
-                    fileModified = true;
-                    totalUpdates++;
-                }
-            }
-        }
-        if (fileModified) {
-            writeFileSync(file, code, 'utf-8');
-        }
-    }
-    return { updated: totalUpdates };
-}

package/templates/react-router/translations/en.json

@@ -1 +0,0 @@
-{}