i18n-turbo 0.1.1 → 1.0.1

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2025 Lasantha Lakmal
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2025 Lasantha Lakmal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,74 +1,142 @@
-# i18n-turbo
-
-> Extract hardcoded strings from JSX/TSX/JS/TS files and export them to an i18n JSON format — with optional reverse transformation support.
-
-## Install
-
-```bash
-npm install -g i18n-turbo
-````
-
-## Usage
-
-```bash
-i18n-turbo <input-dir> <output-en-json> [--dry-run] [--merge] [--lang <code>] [--fn <name>] [--reverse]
-```
-
-## Options
-
-* `--dry-run` — Show what would be replaced, but don’t modify files.
-* `--merge` — Merge new keys with existing `en.json` entries.
-* `--lang <code>` — Automatically translate to the specified language (e.g., `fr`, `es`) and generate `<lang>.json`.
-* `--fn <name>` — Set the i18n function name (default is `t`).
-* `--reverse` — Revert translated keys (e.g., `t("hello_world")`) back to the original hardcoded strings using the translation file.
-
-## Features
-
-* Scans `.jsx`, `.tsx`, `.ts`, `.js` files
-* Extracts static text and replaces with `t('key')`
-* Outputs i18n JSON files (e.g., `en.json`, `fr.json`)
-* Reverses translated keys back to raw strings
-* Preserves original file structure
-* Supports dry-run, merge, and auto-translate
-
-## Examples
-
-### Extract mode
-
-**Dry run only (preview):**
-
-```bash
-i18n-turbo ./src ./locales/en.json --dry-run
-```
-
-**Translate to French and output `fr.json`:**
-
-```bash
-i18n-turbo ./examples ./locales/en.json --lang fr
-```
-
-**Use a custom function name (e.g. `i18n` instead of `t`):**
-
-```bash
-i18n-turbo ./src ./locales/en.json --fn i18n
-```
-
-### Reverse mode
-
-**Revert translations (e.g. `t("hello_world")`) back to original strings:**
-
-```bash
-i18n-turbo ./examples ./locales/en.json --reverse
-```
-
-**Reverse using a custom i18n function name:**
-
-```bash
-i18n-turbo ./src ./locales/en.json --reverse --fn i18n
-```
-
-> 🔁 The reverse command reads keys from the translation file (e.g. `en.json`) and replaces `t("key")` with the original hardcoded string like `"Hello world"`.
-
-## License
-
-MIT
+# i18n-turbo
+
+> 🚀 **Turbocharge your i18n workflow.**
+> Extract hardcoded strings from JSX/TSX/JS/TS files and export them to an i18n JSON format — with minimal configuration and maximum speed.
+
+## Features
+
+- ⚡ **Blazing Fast**: Asynchronous, parallel file processing for large codebases.
+- 🎯 **Smart Extraction**: Detects strings in JSX text, attributes, and variables.
+- 📁 **Namespaces**: Organize translations into multiple files (e.g., `auth.json`, `common.json`) based on file paths.
+- 💬 **Context Support**: Extract comments (`i18n: ...`) as translation context for translators.
+- 🔢 **Pluralization**: Automatically detects singular/plural patterns in ternary operators.
+- 🔧 **Configs**: Flexible `i18n-turbo.config.js` for custom key strategies, exclusions, and more.
+- 🔄 **Reverse Mode**: Revert `t('key')` back to original strings (great for refactoring).
+
+## Install
+
+```bash
+npm install -g i18n-turbo
+```
+
+## Usage
+
+```bash
+i18n-turbo <input-dir> <output-file> [options]
+```
+
+### Examples
+
+**Basic Extraction:**
+```bash
+i18n-turbo ./src ./locales/en.json
+```
+
+**Translate to French:**
+```bash
+i18n-turbo ./src ./locales/en.json --lang fr
+```
+
+**Dry Run (Preview changes):**
+```bash
+i18n-turbo ./src ./locales/en.json --dry-run
+```
+
+**Update existing translations:**
+```bash
+i18n-turbo ./src ./locales/en.json --merge
+```
+
+## Configuration
+
+Create an `i18n-turbo.config.js` file in your project root to customize behavior.
+
+```javascript
+// i18n-turbo.config.js
+module.exports = {
+  // Function Name (default: 't')
+  translationFunction: 't',
+
+  // String Length Threshold (default: 2)
+  minStringLength: 3,
+
+  // Key Generation
+  // Options: 'snake_case', 'camelCase', 'hash', or function(text)
+  keyGenerationStrategy: 'snake_case',
+
+  // Exclude directories/files (glob patterns)
+  excludePatterns: ['**/*.test.tsx', '**/stories/**'],
+
+  // Namespaces (Map source globs to namespace files)
+  namespaces: {
+    'src/features/auth/**': 'auth',
+    'src/features/dashboard/**': 'dashboard',
+    'src/components/**': 'common',
+  },
+
+  // Default target language for machine translation
+  targetLang: 'es'
+};
+```
+
+## Advanced Features
+
+### Namespaces
+Control where your strings go by defining namespaces.
+If you configure `namespaces`, `i18n-turbo` will output separate files in the output directory instead of a single file.
+
+```javascript
+// config
+namespaces: {
+  'src/auth/**': 'auth',
+}
+// Output: locales/auth.json, locales/common.json
+```
+
+### Context Extraction
+Provide context to translators by adding comments starting with `i18n:`.
+The tool is smart enough to find comments attached to the node or its JSX siblings.
+
+**Input:**
+```tsx
+{/* i18n: Title for the landing page */}
+<h1>Welcome Home</h1>
+
+const label = "Submit"; // i18n: Button label
+```
+
+**Output (`en.json`):**
+```json
+{
+  "welcome_home": "Welcome Home",
+  "welcome_home_comment": "Title for the landing page",
+  "submit": "Submit",
+  "submit_comment": "Button label"
+}
+```
+
+### Pluralization
+`i18n-turbo` detects simple pluralization patterns in your code.
+
+**Input:**
+```tsx
+<p>{count === 1 ? "One item" : "Many items"}</p>
+```
+
+**Output:**
+Replaces with `t('one_item')` and `t('many_items')` (Base support).
+*Future updates will implement automatic `t('key', { count })` merging.*
+
+## Key Generation Strategies
+
+- **snake_case**: `Hello World` -> `hello_world` (Default)
+- **camelCase**: `Hello World` -> `helloWorld`
+- **hash**: `Hello World` -> `a1b2c3d4` (Useful for stable keys regardless of content)
+- **Custom**:
+  ```javascript
+  keyGenerationStrategy: (text) => text.toUpperCase().replace(/\s+/g, '_')
+  ```
+
+## License
+
+MIT

package/dist/src/cli.js

@@ -8,19 +8,27 @@ exports.runCLI = runCLI;
 const path_1 = __importDefault(require("path"));
 const extractor_1 = require("./extractor");
 const reverser_1 = require("./reverser");
+const config_1 = require("./config");
 async function runCLI() {
+    const config = (0, config_1.loadConfig)();
     const args = process.argv.slice(2);
     const inputDir = args[0] || './src';
     const outputFile = args[1] || './locales/en.json';
     const fnNameIndex = args.indexOf('--fn');
-    const fnName = fnNameIndex !== -1 && args[fnNameIndex + 1] ? args[fnNameIndex + 1] : 't';
+    // CLI flag takes precedence over config
+    const fnName = fnNameIndex !== -1 && args[fnNameIndex + 1]
+        ? args[fnNameIndex + 1]
+        : (config.translationFunction || 't');
     const langIndex = args.indexOf('--lang');
-    const lang = langIndex !== -1 && args[langIndex + 1] ? args[langIndex + 1] : undefined;
+    const lang = langIndex !== -1 && args[langIndex + 1]
+        ? args[langIndex + 1]
+        : config.targetLang;
     const options = {
         fnName,
         dryRun: args.includes('--dry-run'),
         merge: args.includes('--merge'),
         lang,
+        config,
     };
     const resolvedInputDir = path_1.default.resolve(inputDir);
     const resolvedOutputFile = path_1.default.resolve(outputFile);

package/dist/src/config.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const DEFAULT_CONFIG = {
+    translationFunction: 't',
+    minStringLength: 2,
+    excludePatterns: [],
+    keyGenerationStrategy: 'snake_case',
+};
+function loadConfig(cwd = process.cwd()) {
+    const configPath = path_1.default.join(cwd, 'i18n-turbo.config.js');
+    if (fs_1.default.existsSync(configPath)) {
+        try {
+            // Dynamic require is acceptable for a CLI tool reading local config
+            const userConfig = require(configPath);
+            return { ...DEFAULT_CONFIG, ...userConfig };
+        }
+        catch (error) {
+            console.warn('Warning: Failed to load i18n-turbo.config.js:', error);
+        }
+    }
+    // Future enhancement: support package.json or .json config
+    return DEFAULT_CONFIG;
+}

package/dist/src/extractor.js

@@ -39,6 +39,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractStringsFromDirectory = extractStringsFromDirectory;
 // src/extractor.ts
 const fs_1 = __importDefault(require("fs"));
+const fs_2 = require("fs"); // Async FS
 const path_1 = __importDefault(require("path"));
 const babel = __importStar(require("@babel/core"));
 const traverse_1 = __importDefault(require("@babel/traverse"));
@@ -47,100 +48,309 @@ const t = __importStar(require("@babel/types"));
 const scanner_1 = require("./scanner");
 const utils_1 = require("./utils");
 const google_translate_api_1 = require("@vitalets/google-translate-api");
+const p_limit_1 = __importDefault(require("p-limit"));
+const minimatch_1 = require("minimatch");
 async function extractStringsFromDirectory(inputDir, outputFile, options) {
-    let translationMap = {};
-    if (options.merge && fs_1.default.existsSync(outputFile)) {
-        try {
-            translationMap = JSON.parse(fs_1.default.readFileSync(outputFile, "utf-8"));
-        }
-        catch {
-            console.warn(`[WARN] Could not parse ${outputFile}, starting fresh.`);
-        }
+    // console.log('DEBUG: extractor options.config:', options.config);
+    // Map of namespace name -> translation map
+    const namespaceMaps = {};
+    // Default namespace (if no specific match or fallback)
+    const defaultNamespace = 'common'; // or derive from outputFile basename
+    // Initialize default map
+    if (!options.config?.namespaces) {
+        // If no namespaces configured, use a single map keyed by "default" or just merge everything there.
+        // actually we will simulate namespaces: "default" -> file content
+        namespaceMaps[defaultNamespace] = {};
     }
-    const files = (0, scanner_1.getSourceFiles)(inputDir);
-    for (const file of files) {
-        const code = fs_1.default.readFileSync(file, "utf-8");
-        const ast = babel.parseSync(code, {
-            filename: file,
-            presets: ["@babel/preset-typescript", "@babel/preset-react"],
+    else {
+        // initialize configured namespaces
+        Object.values(options.config.namespaces).forEach(ns => {
+            namespaceMaps[ns] = {};
         });
-        if (!ast)
-            continue;
-        let modified = false;
-        (0, traverse_1.default)(ast, {
-            JSXText(path) {
-                const rawText = path.node.value.trim();
-                if (!rawText || /^\{.*\}$/.test(rawText))
-                    return;
-                const key = (0, utils_1.generateTranslationKey)(rawText);
-                translationMap[key] = rawText;
-                const replacement = t.jsxExpressionContainer(t.callExpression(t.identifier(options.fnName), [t.stringLiteral(key)]));
-                path.replaceWith(replacement);
-                modified = true;
-                if (options.dryRun) {
-                    console.log(`[DRY RUN] ${file}: ${rawText} -> ${key}`);
+        // Ensure default exists for fallbacks
+        namespaceMaps[defaultNamespace] = {};
+    }
+    // Load existing translations if merge is on
+    // Logic update: If namespaces are used, we need to load MULTIPLE files.
+    // For simplicity: If config.namespaces exists, we assume outputFile is a DIRECTORY or prefix base.
+    // But strictly, if user passes `locales/en.json`, we might treat `locales` as the dir.
+    const outputDir = path_1.default.extname(outputFile) ? path_1.default.dirname(outputFile) : outputFile;
+    if (options.merge) {
+        for (const ns of Object.keys(namespaceMaps)) {
+            const nsFile = options.config?.namespaces
+                ? path_1.default.join(outputDir, `${ns}.json`)
+                : outputFile; // If no namespaces, use the single output file
+            if (fs_1.default.existsSync(nsFile)) {
+                try {
+                    namespaceMaps[ns] = JSON.parse(fs_1.default.readFileSync(nsFile, "utf-8"));
                 }
-            },
-            StringLiteral(path) {
-                const value = path.node.value;
-                // ✅ Skip import declarations
-                if (path.findParent((p) => p.isImportDeclaration()))
-                    return;
-                // ✅ Skip if already translated
-                if (path.parentPath.isCallExpression() &&
-                    path.parentPath.node.callee.type === "Identifier" &&
-                    path.parentPath.node.callee.name === options.fnName)
-                    return;
-                if (!value || value.length < 2 || value.length > 80)
-                    return;
-                if (!/[a-zA-Z]/.test(value))
-                    return;
-                const key = (0, utils_1.generateTranslationKey)(value);
-                translationMap[key] = value;
-                let replacement;
-                // ✅ Detect if inside JSX attribute
-                if (path.parentPath.isJSXAttribute()) {
-                    replacement = t.jsxExpressionContainer(t.callExpression(t.identifier(options.fnName), [
-                        t.stringLiteral(key),
-                    ]));
+                catch {
+                    console.warn(`[WARN] Could not parse ${nsFile}, starting fresh.`);
                 }
-                else {
-                    replacement = t.callExpression(t.identifier(options.fnName), [
-                        t.stringLiteral(key),
-                    ]);
+            }
+        }
+    }
+    const files = await (0, scanner_1.getSourceFiles)(inputDir, options.config?.excludePatterns);
+    const limit = (0, p_limit_1.default)(50); // Concurrency limit
+    await Promise.all(files.map((file) => limit(async () => {
+        try {
+            // Read file async
+            const code = await fs_2.promises.readFile(file, "utf-8");
+            // Parse AST (still sync for now as babel.parseAsync just wraps it usually)
+            const ast = babel.parseSync(code, {
+                filename: file,
+                presets: ["@babel/preset-typescript", "@babel/preset-react"],
+            });
+            if (!ast)
+                return;
+            // Determine namespace for this file
+            let currentNs = defaultNamespace;
+            if (options.config?.namespaces) {
+                const relativePath = path_1.default.relative(process.cwd(), file); // or relative to inputDir? relative to CWD usually for globs
+                // Check against globs
+                for (const [pattern, nsName] of Object.entries(options.config.namespaces)) {
+                    if ((0, minimatch_1.minimatch)(relativePath, pattern)) {
+                        currentNs = nsName;
+                        break;
+                    }
+                }
+            }
+            // Ensure map exists (e.g. if we default to common)
+            if (!namespaceMaps[currentNs])
+                namespaceMaps[currentNs] = {};
+            let modified = false;
+            const checkComments = (node) => {
+                if (node.leadingComments) {
+                    const c = node.leadingComments.find(c => c.value.trim().startsWith('i18n:'));
+                    if (c)
+                        return c.value.trim().replace(/^i18n:\s*/, '');
                 }
-                path.replaceWith(replacement);
-                modified = true;
-                if (options.dryRun) {
-                    console.log(`[DRY RUN] ${file}: "${value}" -> ${key}`);
+                return undefined;
+            };
+            const getContextFromSibling = (path) => {
+                if (typeof path.key === 'number' && Array.isArray(path.container)) {
+                    let k = path.key - 1;
+                    while (k >= 0) {
+                        const prevNode = path.container[k];
+                        if (t.isJSXText(prevNode) && !prevNode.value.trim()) {
+                            k--;
+                            continue;
+                        }
+                        if (t.isJSXExpressionContainer(prevNode) && t.isJSXEmptyExpression(prevNode.expression)) {
+                            const comments = prevNode.expression.innerComments;
+                            if (comments) {
+                                const c = comments.find((c) => c.value.trim().startsWith('i18n:'));
+                                if (c)
+                                    return c.value.trim().replace(/^i18n:\s*/, '');
+                            }
+                        }
+                        // If we hit a non-empty text or other node that is not comment, stop?
+                        // The comment should be immediately preceding (ignoring whitespace).
+                        // If we found another Element, assume no comment for this one.
+                        break;
+                    }
                 }
-            },
-        });
-        if (!options.dryRun && modified) {
-            const output = (0, generator_1.default)(ast).code;
-            fs_1.default.writeFileSync(file, output);
+                return undefined;
+            };
+            (0, traverse_1.default)(ast, {
+                JSXText(path) {
+                    const rawText = path.node.value.trim();
+                    if (!rawText || /^\{.*\}$/.test(rawText))
+                        return;
+                    // Check for context comments (i18n: ...)
+                    let contextComment;
+                    // Standard comments (leading)
+                    const comment = checkComments(path.node) ||
+                        (path.parentPath?.node && checkComments(path.parentPath.node));
+                    // Sibling comments (JSX expression container before parent Element)
+                    const siblingComment = path.parentPath ? getContextFromSibling(path.parentPath) : undefined;
+                    contextComment = comment || siblingComment;
+                    const key = (0, utils_1.generateTranslationKey)(rawText, options.config?.keyGenerationStrategy);
+                    namespaceMaps[currentNs][key] = rawText;
+                    if (contextComment) {
+                        namespaceMaps[currentNs][`${key}_comment`] = contextComment;
+                    }
+                    const replacement = t.jsxExpressionContainer(t.callExpression(t.identifier(options.fnName), [
+                        t.stringLiteral(key),
+                    ]));
+                    path.replaceWith(replacement);
+                    modified = true;
+                    if (options.dryRun) {
+                        console.log(`[DRY RUN] ${file} (${currentNs}): ${rawText} -> ${key}`);
+                    }
+                },
+                StringLiteral(path) {
+                    const value = path.node.value;
+                    // ✅ Check for context comments (i18n: ...)
+                    // Check the node or its parent (e.g. if inside specific call/JSX)
+                    let contextComment;
+                    // Check current node, parent, or 2nd parent (e.g. JSXAttribute -> JSXOpeningElement -> JSXElement?)
+                    // For JSX: Text -> JSXElement (parent).
+                    // For StringLiteral inside JSX: StringLiteral -> JSXAttribute -> JSXOpeningElement ...
+                    // Test case: {/* comment */} <h1>Text</h1>
+                    // Here comment is sibling?
+                    // Babel attaches 'leadingComments' to the subsequent node.
+                    // So 'Text' might have leadingComments? Or 'h1' has them?
+                    // If 'Text' is inside 'h1', 'h1' has the comments.
+                    // so `path.parentPath`?
+                    const comment = checkComments(path.node) ||
+                        (path.parentPath?.node && checkComments(path.parentPath.node)) ||
+                        (path.parentPath?.parentPath?.node && checkComments(path.parentPath.parentPath.node));
+                    if (comment) {
+                        contextComment = comment;
+                    }
+                    else {
+                        // Try finding sibling comment if inside JSX Element (e.g. Attribute -> OpeningElement -> Element)
+                        const elementPath = path.findParent(p => p.isJSXElement());
+                        if (elementPath) {
+                            contextComment = getContextFromSibling(elementPath);
+                        }
+                    }
+                    // ✅ Skip import declarations
+                    if (path.findParent((p) => p.isImportDeclaration()))
+                        return;
+                    // ✅ Skip require('...') calls
+                    if (path.parentPath.isCallExpression() &&
+                        t.isIdentifier(path.parentPath.node.callee) &&
+                        path.parentPath.node.callee.name === "require")
+                        return;
+                    // ✅ Skip if already translated
+                    if (path.parentPath.isCallExpression() &&
+                        path.parentPath.node.callee.type === "Identifier" &&
+                        path.parentPath.node.callee.name === options.fnName)
+                        return;
+                    if (!value ||
+                        value.length < (options.config?.minStringLength || 2) ||
+                        value.length > 80)
+                        return;
+                    if (!/[a-zA-Z]/.test(value))
+                        return;
+                    const key = (0, utils_1.generateTranslationKey)(value, options.config?.keyGenerationStrategy);
+                    // console.log(`DEBUG: key for "${value}" -> "${key}"`);
+                    namespaceMaps[currentNs][key] = value;
+                    if (contextComment) {
+                        namespaceMaps[currentNs][`${key}_comment`] = contextComment;
+                    }
+                    let replacement;
+                    // ✅ Detect if inside ignored JSX attribute (direct or nested)
+                    const attributePath = path.findParent((p) => p.isJSXAttribute());
+                    if (attributePath && attributePath.isJSXAttribute()) {
+                        const attrName = attributePath.node.name;
+                        if (t.isJSXIdentifier(attrName) &&
+                            [
+                                "data-testid",
+                                "className",
+                                "style",
+                                "id",
+                                "key",
+                                "ref",
+                                "width",
+                                "height",
+                                "href",
+                                "src",
+                                "type",
+                                "rel",
+                                "target",
+                                "alt",
+                                "placeholder",
+                            ].includes(attrName.name))
+                            return;
+                    }
+                    // ✅ If inside JSX attribute (but not ignored), we need JSX wrapper
+                    if (path.parentPath.isJSXAttribute()) {
+                        // Double check we are direct child (standard string attr)
+                        replacement = t.jsxExpressionContainer(t.callExpression(t.identifier(options.fnName), [
+                            t.stringLiteral(key),
+                        ]));
+                    }
+                    else {
+                        replacement = t.callExpression(t.identifier(options.fnName), [
+                            t.stringLiteral(key),
+                        ]);
+                    }
+                    path.replaceWith(replacement);
+                    modified = true;
+                    if (options.dryRun) {
+                        console.log(`[DRY RUN] ${file} (${currentNs}): "${value}" -> ${key}`);
+                    }
+                },
+            });
+            if (!options.dryRun && modified) {
+                const output = (0, generator_1.default)(ast).code;
+                // Write file async
+                await fs_2.promises.writeFile(file, output);
+            }
         }
-    }
+        catch (err) {
+            console.error(`Error processing file ${file}: `, err);
+        }
+    })));
     if (!options.dryRun) {
-        fs_1.default.mkdirSync(path_1.default.dirname(outputFile), { recursive: true });
-        if (options.lang && options.lang !== "en") {
-            const translated = {};
-            for (const [key, text] of Object.entries(translationMap)) {
-                try {
-                    const res = await (0, google_translate_api_1.translate)(text, { to: options.lang });
-                    console.log(`Translated "${text}" => "${res.text}"`);
-                    translated[key] = res.text;
+        if (outputDir !== ".") {
+            await fs_2.promises.mkdir(outputDir, { recursive: true });
+        }
+        // Write all namespace files
+        for (const [ns, map] of Object.entries(namespaceMaps)) {
+            if (Object.keys(map).length === 0 && ns !== defaultNamespace)
+                continue; // Skip empty non-default/extra namespaces if explicit? Actually keep them empty if created? 
+            // Let's write them if they have content OR they are the expected output.
+            if (Object.keys(map).length === 0 && !options.config?.namespaces)
+                continue; // If no config, don't write empty 'common' if empty? No, we should writes.
+            let targetFile = outputFile;
+            if (options.config?.namespaces) {
+                // If namespaces are used, outputFile is treated as base dir for default locale?
+                // Or we append ns to outputDir?
+                // Logic: if namespaces active, we construct file paths like `outputDir/ns.json` 
+                // OR if targetLang is active `outputDir/lang/ns.json`.
+                // Wait, existing logic for Lang:
+                // `path.join(path.dirname(outputFile), `${options.lang}.json`)`
+                // New logic:
+                // If namespaces:
+                //   Target File = `outputDir/ns.json` (for default/en)
+                //   If --lang: `outputDir/ns.lang.json` ?? OR `outputDir/lang/ns.json`?
+                //   Common pattern: `locales/en/common.json`.
+                // Let's assume `outputFile` denotes the folder structure for the default file.
+                // e.g. `locales/en.json` -> outputDir = `locales`
+                // If namespaces active: `locales/common.json`, `locales/auth.json`.
+                targetFile = path_1.default.join(outputDir, `${ns}.json`);
+            }
+            const mapToWrite = map;
+            // Translation logic
+            if (options.lang && options.lang !== "en") {
+                const translated = {};
+                for (const [key, text] of Object.entries(map)) {
+                    try {
+                        const res = await (0, google_translate_api_1.translate)(text, { to: options.lang });
+                        console.log(`Translated [${ns}] "${text}" => "${res.text}"`);
+                        translated[key] = res.text;
+                    }
+                    catch (err) {
+                        console.warn(`Translation failed for "${text}"`, err);
+                        translated[key] = text;
+                    }
                 }
-                catch (err) {
-                    console.warn(`Translation failed for "${text}"`, err);
-                    translated[key] = text;
+                // If namespaces active: `locales/lang/ns.json` or `locales/ns.lang.json`?
+                // Let's do `locales/lang.json` if single file, 
+                // BUT if namespaces: `locales/ns.json` (en), `locales/ns_fr.json`?
+                // OR `locales/fr/ns.json`.
+                // Let's stick to `locales/fr.json` if NO namespaces (legacy).
+                // If namespaces: `locales/fr/ns.json`? Or `locales/ns.fr.json`?
+                // Complexity increase!
+                // Simplified for this task:
+                // If namespaces: write `outputDir/ns.json`. If lang available, write `outputDir/ns_lang.json` (flat).
+                let langPath;
+                if (options.config?.namespaces) {
+                    langPath = path_1.default.join(outputDir, `${ns}_${options.lang}.json`);
                 }
+                else {
+                    langPath = path_1.default.join(path_1.default.dirname(outputFile), `${options.lang}.json`);
+                }
+                await fs_2.promises.writeFile(langPath, JSON.stringify(translated, null, 2), "utf-8");
+            }
+            else {
+                // Default language (usually EN)
+                await fs_2.promises.writeFile(targetFile, JSON.stringify(mapToWrite, null, 2), "utf-8");
             }
-            const langPath = path_1.default.join(path_1.default.dirname(outputFile), `${options.lang}.json`);
-            fs_1.default.writeFileSync(langPath, JSON.stringify(translated, null, 2), "utf-8");
-        }
-        else {
-            fs_1.default.writeFileSync(outputFile, JSON.stringify(translationMap, null, 2), "utf-8");
         }
     }
 }

package/dist/src/reverser.js

@@ -43,9 +43,9 @@ const traverse_1 = __importDefault(require("@babel/traverse"));
 const t = __importStar(require("@babel/types"));
 const generator_1 = __importDefault(require("@babel/generator"));
 const scanner_1 = require("./scanner");
-function reverseStringsFromDirectory(inputDir, i18nFile, fnName = "t") {
+async function reverseStringsFromDirectory(inputDir, i18nFile, fnName = "t") {
     const translationMap = JSON.parse(fs_1.default.readFileSync(i18nFile, "utf-8"));
-    const files = (0, scanner_1.getSourceFiles)(inputDir);
+    const files = await (0, scanner_1.getSourceFiles)(inputDir);
     for (const file of files) {
         const code = fs_1.default.readFileSync(file, "utf-8");
         const ast = babel.parseSync(code, {

package/dist/src/scanner.js

@@ -1,43 +1,13 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSourceFiles = getSourceFiles;
-// src/scanner.ts
-const glob = __importStar(require("glob"));
-function getSourceFiles(dir) {
-    return glob.sync(`${dir}/**/*.{js,jsx,ts,tsx}`, {
-        nodir: true
+const glob_1 = require("glob");
+async function getSourceFiles(dir, excludes = []) {
+    console.log(`Scanning dir: ${dir}, excludes: ${excludes}`);
+    const files = await (0, glob_1.glob)(`${dir}/**/*.{js,jsx,ts,tsx}`, {
+        nodir: true,
+        ignore: ['**/node_modules/**', '**/dist/**', ...excludes]
     });
+    console.log(`Found ${files.length} files.`);
+    return files;
 }

package/dist/src/utils.js

@@ -1,7 +1,30 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateTranslationKey = generateTranslationKey;
-// src/utils.ts
-function generateTranslationKey(text) {
+const crypto_1 = __importDefault(require("crypto"));
+function generateTranslationKey(text, strategy = 'snake_case') {
+    if (typeof strategy === 'function') {
+        return strategy(text);
+    }
+    switch (strategy) {
+        case 'camelCase':
+            return toCamelCase(text);
+        case 'hash':
+            return crypto_1.default.createHash('md5').update(text).digest('hex').substring(0, 8);
+        case 'snake_case':
+        default:
+            return toSnakeCase(text);
+    }
+}
+function toSnakeCase(text) {
     return text.toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '').substring(0, 50);
 }
+function toCamelCase(text) {
+    return text
+        .replace(/(?:^\w|[A-Z]|\b\w)/g, (word, index) => index === 0 ? word.toLowerCase() : word.toUpperCase())
+        .replace(/\s+/g, '')
+        .replace(/[^a-zA-Z0-9]/g, '');
+}

package/package.json

@@ -1,55 +1,58 @@
-{
-  "name": "i18n-turbo",
-  "version": "0.1.1",
-  "description": "Extract hardcoded text from JSX/TSX files and convert to i18n format.",
-  "main": "dist/index.js",
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
-  "bin": {
-    "i18n-turbo": "dist/bin/cli.js"
-  },
-  "scripts": {
-    "build": "tsc",
-    "start": "ts-node bin/cli.ts",
-    "test": "vitest",
-    "prepare": "npm run build"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/lasalasa/i18n-turbo.git"
-  },
-  "keywords": [
-    "i18n",
-    "translation",
-    "react",
-    "cli",
-    "internationalization"
-  ],
-  "author": "Lasantha Lakmal",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/lasalasa/i18n-turbo.git/issues"
-  },
-  "homepage": "https://github.com/lasalasa/i18n-turbo#readme",
-  "dependencies": {
-    "@babel/core": "^7.0.0",
-    "@babel/generator": "^7.0.0",
-    "@babel/preset-react": "^7.0.0",
-    "@babel/preset-typescript": "^7.0.0",
-    "@babel/traverse": "^7.0.0",
-    "@babel/types": "^7.0.0",
-    "@vitalets/google-translate-api": "^9.2.1",
-    "glob": "^10.4.5"
-  },
-  "devDependencies": {
-    "@types/babel__core": "^7.20.5",
-    "@types/babel__generator": "^7.27.0",
-    "@types/babel__traverse": "^7.20.7",
-    "ts-node": "^10.0.0",
-    "typescript": "^5.0.0",
-    "vitest": "^3.2.4"
-  }
-}
+{
+  "name": "i18n-turbo",
+  "version": "1.0.1",
+  "description": "Extract hardcoded text from JSX/TSX files and convert to i18n format.",
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "i18n-turbo": "dist/bin/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "ts-node bin/cli.ts",
+    "test": "vitest",
+    "prepare": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lasalasa/i18n-turbo.git"
+  },
+  "keywords": [
+    "i18n",
+    "translation",
+    "react",
+    "cli",
+    "internationalization"
+  ],
+  "author": "Lasantha Lakmal",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/lasalasa/i18n-turbo.git/issues"
+  },
+  "homepage": "https://github.com/lasalasa/i18n-turbo#readme",
+  "dependencies": {
+    "@babel/core": "^7.0.0",
+    "@babel/generator": "^7.0.0",
+    "@babel/preset-react": "^7.0.0",
+    "@babel/preset-typescript": "^7.0.0",
+    "@babel/traverse": "^7.0.0",
+    "@babel/types": "^7.0.0",
+    "@types/minimatch": "^5.1.2",
+    "@vitalets/google-translate-api": "^9.2.1",
+    "glob": "^10.4.5",
+    "minimatch": "^10.1.1",
+    "p-limit": "^3.1.0"
+  },
+  "devDependencies": {
+    "@types/babel__core": "^7.20.5",
+    "@types/babel__generator": "^7.27.0",
+    "@types/babel__traverse": "^7.20.7",
+    "ts-node": "^10.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^3.2.4"
+  }
+}