@strato-admin/i18n-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vadim Gubergrits
+
+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

@@ -0,0 +1,38 @@
+# @strato-admin/i18n-cli
+
+CLI tools for Strato Admin internationalization.
+
+## Extraction
+
+The `strato-extract` command extracts translatable strings from your source code into translation files (JSON or PO).
+
+```bash
+# Basic usage
+strato-extract "src/**/*.{ts,tsx}" locales en fr
+
+# Extract to PO files
+strato-extract "src/**/*.{ts,tsx}" "locales/*/messages.po"
+
+# Use a custom configuration file
+strato-extract --config=my-config.json "src/**/*.{ts,tsx}" "locales/*/messages.po"
+```
+
+## Configuration
+
+You can configure the extraction process by creating a `@strato-admin/i18n.config.json` file in your project root, or by specifying a path using the `--config` flag.
+
+The configuration allows you to extend the list of components and attributes that the extractor looks for.
+
+### Example `@strato-admin/i18n.config.json`
+
+```json
+{
+  "components": ["MyCustomButton", "SpecialHeader", "Namespace.Component"],
+  "translatableProps": ["customLabel", "headerTitle", "tooltip"]
+}
+```
+
+- **components**: An array of component names (e.g., `Button`, `Table.Col`). The extractor will search for JSX elements matching these names.
+- **translatableProps**: An array of prop names (e.g., `label`, `title`). The extractor will extract the string values of these props when found on any of the specified components.
+
+By default, the extractor includes all standard Strato Admin components and common translatable props like `label`, `title`, `placeholder`, etc. Providing a configuration file adds your custom components and props to these defaults.

package/dist/cli/compile.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/compile.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import * as fs from 'fs';
+import * as path from 'path';
+import { globSync } from 'glob';
+import * as gettextParser from 'gettext-parser';
+function main() {
+    const args = process.argv.slice(2);
+    const pattern = args[0] || 'locales';
+    let files = [];
+    if (fs.existsSync(pattern) && fs.statSync(pattern).isDirectory()) {
+        // Original behavior: if a directory is passed, find .json and .po files inside it
+        files = fs.readdirSync(pattern)
+            .filter(file => (file.endsWith('.json') || file.endsWith('.po')) && !file.endsWith('.compiled.json'))
+            .map(file => path.join(pattern, file));
+    }
+    else {
+        // New behavior: support glob patterns
+        files = globSync(pattern, { absolute: true })
+            .filter(file => (file.endsWith('.json') || file.endsWith('.po')) && !file.endsWith('.compiled.json'));
+    }
+    if (files.length === 0) {
+        console.log(`No .json or .po files found matching: ${pattern}`);
+        return;
+    }
+    let processedCount = 0;
+    files.forEach(filePath => {
+        const compiledFilePath = filePath.replace(/\.(json|po)$/, '.compiled.json');
+        const fileName = path.basename(filePath);
+        let translations = {};
+        try {
+            if (filePath.endsWith('.po')) {
+                const parsed = gettextParser.po.parse(fs.readFileSync(filePath));
+                Object.entries(parsed.translations).forEach(([context, entries]) => {
+                    Object.entries(entries).forEach(([msgid, data]) => {
+                        if (msgid === '')
+                            return; // skip header
+                        // Find the hash: check context (v2), then comment (v3), then msgid (v1)
+                        const commentHash = data.comments?.extracted?.match(/id: (\w+)/)?.[1];
+                        const hash = context || commentHash || msgid;
+                        translations[hash] = {
+                            defaultMessage: data.msgid || data.comments?.extracted || '',
+                            translation: data.msgstr[0] || ''
+                        };
+                    });
+                });
+            }
+            else {
+                translations = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+            }
+        }
+        catch (e) {
+            console.error(`Failed to parse translation file at ${filePath}:`, e.message);
+            return;
+        }
+        const compiledMapping = {};
+        Object.entries(translations).forEach(([msgid, data]) => {
+            // If translation is empty or whitespace, fallback to defaultMessage
+            if (data.translation && data.translation.trim() !== '') {
+                compiledMapping[msgid] = data.translation;
+            }
+            else {
+                compiledMapping[msgid] = data.defaultMessage;
+            }
+        });
+        fs.writeFileSync(compiledFilePath, JSON.stringify(compiledMapping, null, 2));
+        console.log(`Compiled ${fileName} -> ${path.basename(compiledFilePath)} (${Object.keys(compiledMapping).length} messages)`);
+        processedCount++;
+    });
+    console.log(`Successfully compiled ${processedCount} files.`);
+}
+if (require.main === module) {
+    main();
+}

package/dist/cli/extract.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/extract.js

@@ -0,0 +1,317 @@
+#!/usr/bin/env node
+import * as fs from 'fs';
+import * as path from 'path';
+import { globSync } from 'glob';
+import { parse } from '@babel/parser';
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
+import * as gettextParser from 'gettext-parser';
+import { generateMessageId } from '@strato-admin/i18n';
+// List of Strato Admin components to extract from
+const DEFAULT_STRATO_COMPONENTS = new Set([
+    'ArrayField',
+    'AttributeEditor',
+    'AutocompleteInput',
+    'BooleanField',
+    'BulkDeleteButton',
+    'Button',
+    'Create',
+    'CreateButton',
+    'DateField',
+    'Edit',
+    'EditButton',
+    'FormField',
+    'List',
+    'NumberField',
+    'NumberInput',
+    'ReferenceField',
+    'ReferenceInput',
+    'ReferenceManyField',
+    'Resource',
+    'ResourceSchema',
+    'SaveButton',
+    'SelectInput',
+    'Show',
+    'StatusIndicatorField.Label',
+    'Table',
+    'Table.Col',
+    'TextAreaInput',
+    'TextField',
+    'TextInput',
+]);
+// List of translatable props
+const DEFAULT_TRANSLATABLE_PROPS = new Set([
+    'label',
+    'title',
+    'placeholder',
+    'emptyText',
+    'helperText',
+    'description',
+    'successMessage',
+    'errorMessage',
+]);
+function loadConfig(configPath) {
+    const components = new Set(DEFAULT_STRATO_COMPONENTS);
+    const translatableProps = new Set(DEFAULT_TRANSLATABLE_PROPS);
+    const resolvedConfigPath = configPath || path.join(process.cwd(), 'strato-i18n.config.json');
+    if (fs.existsSync(resolvedConfigPath)) {
+        try {
+            const config = JSON.parse(fs.readFileSync(resolvedConfigPath, 'utf8'));
+            if (config.components) {
+                config.components.forEach((c) => components.add(c));
+            }
+            if (config.translatableProps) {
+                config.translatableProps.forEach((p) => translatableProps.add(p));
+            }
+            console.log(`Loaded configuration from ${resolvedConfigPath}`);
+        }
+        catch (e) {
+            console.error(`Failed to parse configuration file at ${resolvedConfigPath}:`, e.message);
+        }
+    }
+    return { components, translatableProps };
+}
+function getJSXElementName(node) {
+    if (t.isJSXIdentifier(node)) {
+        return node.name;
+    }
+    if (t.isJSXMemberExpression(node)) {
+        return `${getJSXElementName(node.object)}.${node.property.name}`;
+    }
+    if (t.isJSXNamespacedName(node)) {
+        return `${node.namespace.name}:${node.name.name}`;
+    }
+    return '';
+}
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let format = undefined;
+    let config = undefined;
+    const positionalArgs = [];
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--format' && i + 1 < args.length) {
+            format = args[i + 1];
+            i++;
+        }
+        else if (args[i].startsWith('--format=')) {
+            format = args[i].split('=')[1];
+        }
+        else if (args[i] === '--config' && i + 1 < args.length) {
+            config = args[i + 1];
+            i++;
+        }
+        else if (args[i].startsWith('--config=')) {
+            config = args[i].split('=')[1];
+        }
+        else {
+            positionalArgs.push(args[i]);
+        }
+    }
+    const srcPattern = positionalArgs[0] || 'src/**/*.{ts,tsx}';
+    let outDir = 'locales';
+    let localeArgs = [];
+    if (positionalArgs.length > 1) {
+        if (positionalArgs[1].includes('*')) {
+            // First target is a glob, so we treat ALL subsequent args as targets
+            outDir = '.';
+            localeArgs = positionalArgs.slice(1);
+        }
+        else {
+            // First target is a directory
+            outDir = positionalArgs[1];
+            localeArgs = positionalArgs.slice(2);
+            if (localeArgs.length === 0) {
+                localeArgs = ['en'];
+            }
+        }
+    }
+    else {
+        localeArgs = ['en'];
+    }
+    return { srcPattern, outDir, localeArgs, format, config };
+}
+function main() {
+    const { srcPattern, outDir, localeArgs, format: formatArg, config: configPath } = parseArgs();
+    const { components, translatableProps } = loadConfig(configPath);
+    console.log(`Extracting messages from ${srcPattern} (using Babel)...`);
+    const files = globSync(srcPattern, { absolute: true });
+    const extractedMessages = new Set();
+    files.forEach((file) => {
+        try {
+            const content = fs.readFileSync(file, 'utf8');
+            const ast = parse(content, {
+                sourceType: 'module',
+                plugins: ['typescript', 'jsx', 'decorators-legacy'],
+            });
+            traverse(ast, {
+                JSXOpeningElement(path) {
+                    const tagName = getJSXElementName(path.node.name);
+                    const baseNameMatch = components.has(tagName) || Array.from(components).some((c) => tagName.startsWith(c + '.') || tagName === c);
+                    if (baseNameMatch) {
+                        path.node.attributes.forEach((attr) => {
+                            if (t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name) && translatableProps.has(attr.name.name)) {
+                                let textValue = null;
+                                if (attr.value) {
+                                    if (t.isStringLiteral(attr.value)) {
+                                        textValue = attr.value.value;
+                                    }
+                                    else if (t.isJSXExpressionContainer(attr.value)) {
+                                        const expr = attr.value.expression;
+                                        if (t.isStringLiteral(expr) || t.isTemplateLiteral(expr)) {
+                                            if (t.isStringLiteral(expr)) {
+                                                textValue = expr.value;
+                                            }
+                                            else if (expr.quasis.length === 1) {
+                                                textValue = expr.quasis[0].value.raw;
+                                            }
+                                        }
+                                    }
+                                }
+                                if (textValue && textValue.trim() !== '') {
+                                    extractedMessages.add(textValue);
+                                }
+                            }
+                        });
+                    }
+                },
+            });
+        }
+        catch (e) {
+            console.error(`Failed to parse ${file}:`, e.message);
+        }
+    });
+    console.log(`Found ${extractedMessages.size} translatable strings.`);
+    const targets = [];
+    localeArgs.forEach((arg) => {
+        if (arg.includes('*')) {
+            const matchedFiles = globSync(arg, { absolute: true });
+            matchedFiles.forEach((file) => {
+                const ext = path.extname(file).slice(1);
+                const format = formatArg || (ext === 'po' ? 'po' : 'json');
+                // Guess locale from path: locales/en.po -> en, locales/en/messages.po -> en
+                let locale = path.basename(file, '.' + ext);
+                if (locale === 'messages' || locale === 'translations' || locale === 'LC_MESSAGES') {
+                    const parts = file.split(path.sep);
+                    locale = parts[parts.length - 2];
+                }
+                targets.push({ outFile: file, locale, format });
+            });
+        }
+        else {
+            let outFile;
+            let locale;
+            let format;
+            if (arg.includes('.') || arg.includes('/') || arg.includes('\\')) {
+                outFile = arg;
+                const ext = path.extname(arg).slice(1);
+                format = formatArg || (ext === 'po' ? 'po' : 'json');
+                locale = path.basename(arg, '.' + ext);
+                if (locale === 'messages' || locale === 'translations' || locale === 'LC_MESSAGES') {
+                    const parts = path.resolve(arg).split(path.sep);
+                    locale = parts[parts.length - 2];
+                }
+            }
+            else {
+                format = formatArg || 'json';
+                const extension = format === 'po' ? 'po' : 'json';
+                outFile = path.join(outDir, `${arg}.${extension}`);
+                locale = arg;
+            }
+            targets.push({ outFile, locale, format });
+        }
+    });
+    if (targets.length === 0) {
+        console.error('No target files found or specified.');
+        process.exit(1);
+    }
+    targets.forEach(({ outFile, locale, format }) => {
+        let existingTranslations = {};
+        if (fs.existsSync(outFile)) {
+            try {
+                if (format === 'po') {
+                    const fileContent = fs.readFileSync(outFile);
+                    const parsedPo = gettextParser.po.parse(fileContent);
+                    Object.entries(parsedPo.translations).forEach(([context, entries]) => {
+                        Object.entries(entries).forEach(([msgid, data]) => {
+                            if (msgid === '')
+                                return;
+                            // Find the hash: check context (v2), then comment (v3), then msgid (v1)
+                            const commentHash = data.comments?.extracted?.match(/id: (\w+)/)?.[1];
+                            const hash = context || commentHash || msgid;
+                            existingTranslations[hash] = {
+                                defaultMessage: data.msgid || data.comments?.extracted || '',
+                                translation: data.msgstr[0] || '',
+                            };
+                        });
+                    });
+                }
+                else {
+                    existingTranslations = JSON.parse(fs.readFileSync(outFile, 'utf8'));
+                }
+            }
+            catch (e) {
+                console.error(`Failed to parse existing translation file at ${outFile}:`, e.message);
+                return; // Skip this file
+            }
+        }
+        else {
+            const parentDir = path.dirname(outFile);
+            if (!fs.existsSync(parentDir)) {
+                fs.mkdirSync(parentDir, { recursive: true });
+            }
+        }
+        const updatedTranslations = {};
+        let addedCount = 0;
+        extractedMessages.forEach((msg) => {
+            const msgid = generateMessageId(msg);
+            if (existingTranslations[msgid]) {
+                updatedTranslations[msgid] = { ...existingTranslations[msgid] };
+                updatedTranslations[msgid].defaultMessage = msg;
+            }
+            else {
+                updatedTranslations[msgid] = {
+                    defaultMessage: msg,
+                    translation: '',
+                };
+                addedCount++;
+            }
+        });
+        Object.keys(existingTranslations).forEach((key) => {
+            if (!updatedTranslations[key]) {
+                updatedTranslations[key] = existingTranslations[key];
+            }
+        });
+        if (format === 'po') {
+            const poData = {
+                charset: 'utf-8',
+                headers: {
+                    'content-type': 'text/plain; charset=utf-8',
+                    language: locale,
+                },
+                translations: {
+                    '': {
+                        '': { msgid: '', msgstr: [''] }, // Header
+                    },
+                },
+            };
+            Object.entries(updatedTranslations).forEach(([hash, data]) => {
+                poData.translations[''][data.defaultMessage] = {
+                    msgid: data.defaultMessage,
+                    msgstr: [data.translation],
+                    comments: {
+                        extracted: `id: ${hash}`,
+                    },
+                };
+            });
+            const compiledPo = gettextParser.po.compile(poData);
+            fs.writeFileSync(outFile, compiledPo);
+        }
+        else {
+            fs.writeFileSync(outFile, JSON.stringify(updatedTranslations, null, 2));
+        }
+        console.log(`Updated ${outFile} (${locale}): Added ${addedCount} new messages.`);
+    });
+}
+if (require.main === module) {
+    main();
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@strato-admin/i18n-cli",
+  "version": "0.1.0",
+  "description": "Strato Admin I18n CLI - Tools for internationalization and extraction",
+  "main": "dist/cli/extract.js",
+  "types": "dist/cli/extract.d.ts",
+  "bin": {
+    "strato-extract": "./dist/cli/extract.js",
+    "strato-compile": "./dist/cli/compile.js"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "strato",
+    "admin",
+    "react-admin",
+    "i18n",
+    "cli"
+  ],
+  "author": "Vadim Gubergrits <vadim.gubergrits@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vgrits/strato-admin.git",
+    "directory": "packages/strato-i18n-cli"
+  },
+  "dependencies": {
+    "@babel/core": "^7.29.0",
+    "@babel/parser": "^7.29.0",
+    "@babel/traverse": "^7.29.0",
+    "@babel/types": "^7.29.0",
+    "gettext-parser": "^9.0.1",
+    "glob": "^13.0.6",
+    "typescript": "^5.9.3",
+    "@strato-admin/i18n": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/babel__core": "^7.20.5",
+    "@types/babel__traverse": "^7.28.0",
+    "@types/gettext-parser": "^9.0.0",
+    "@types/node": "^25.5.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json"
+  }
+}

package/src/cli/compile.ts

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+import * as fs from 'fs';
+import * as path from 'path';
+import { globSync } from 'glob';
+import * as gettextParser from 'gettext-parser';
+
+function main() {
+  const args = process.argv.slice(2);
+  const pattern = args[0] || 'locales';
+
+  let files: string[] = [];
+
+  if (fs.existsSync(pattern) && fs.statSync(pattern).isDirectory()) {
+    // Original behavior: if a directory is passed, find .json and .po files inside it
+    files = fs.readdirSync(pattern)
+      .filter(file => (file.endsWith('.json') || file.endsWith('.po')) && !file.endsWith('.compiled.json'))
+      .map(file => path.join(pattern, file));
+  } else {
+    // New behavior: support glob patterns
+    files = globSync(pattern, { absolute: true })
+      .filter(file => (file.endsWith('.json') || file.endsWith('.po')) && !file.endsWith('.compiled.json'));
+  }
+
+  if (files.length === 0) {
+    console.log(`No .json or .po files found matching: ${pattern}`);
+    return;
+  }
+
+  let processedCount = 0;
+
+  files.forEach(filePath => {
+    const compiledFilePath = filePath.replace(/\.(json|po)$/, '.compiled.json');
+    const fileName = path.basename(filePath);
+
+    let translations: Record<string, { defaultMessage: string, translation: string }> = {};
+
+    try {
+      if (filePath.endsWith('.po')) {
+        const parsed = gettextParser.po.parse(fs.readFileSync(filePath));
+        
+        Object.entries(parsed.translations).forEach(([context, entries]) => {
+          Object.entries(entries).forEach(([msgid, data]: [string, any]) => {
+            if (msgid === '') return; // skip header
+            
+            // Find the hash: check context (v2), then comment (v3), then msgid (v1)
+            const commentHash = data.comments?.extracted?.match(/id: (\w+)/)?.[1];
+            const hash = context || commentHash || msgid;
+
+            translations[hash] = {
+              defaultMessage: data.msgid || data.comments?.extracted || '',
+              translation: data.msgstr[0] || ''
+            };
+          });
+        });
+      } else {
+        translations = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+      }
+    } catch (e: any) {
+      console.error(`Failed to parse translation file at ${filePath}:`, e.message);
+      return;
+    }
+
+    const compiledMapping: Record<string, string> = {};
+
+    Object.entries(translations).forEach(([msgid, data]) => {
+      // If translation is empty or whitespace, fallback to defaultMessage
+      if (data.translation && data.translation.trim() !== '') {
+        compiledMapping[msgid] = data.translation;
+      } else {
+        compiledMapping[msgid] = data.defaultMessage;
+      }
+    });
+
+    fs.writeFileSync(compiledFilePath, JSON.stringify(compiledMapping, null, 2));
+    console.log(`Compiled ${fileName} -> ${path.basename(compiledFilePath)} (${Object.keys(compiledMapping).length} messages)`);
+    processedCount++;
+  });
+
+  console.log(`Successfully compiled ${processedCount} files.`);
+}
+
+if (require.main === module) {
+  main();
+}

package/src/cli/extract.ts

@@ -0,0 +1,347 @@
+#!/usr/bin/env node
+import * as fs from 'fs';
+import * as path from 'path';
+import { globSync } from 'glob';
+import { parse } from '@babel/parser';
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
+import * as gettextParser from 'gettext-parser';
+import { generateMessageId } from '@strato-admin/i18n';
+
+// List of Strato Admin components to extract from
+const DEFAULT_STRATO_COMPONENTS = new Set([
+  'ArrayField',
+  'AttributeEditor',
+  'AutocompleteInput',
+  'BooleanField',
+  'BulkDeleteButton',
+  'Button',
+  'Create',
+  'CreateButton',
+  'DateField',
+  'Edit',
+  'EditButton',
+  'FormField',
+  'List',
+  'NumberField',
+  'NumberInput',
+  'ReferenceField',
+  'ReferenceInput',
+  'ReferenceManyField',
+  'Resource',
+  'ResourceSchema',
+  'SaveButton',
+  'SelectInput',
+  'Show',
+  'StatusIndicatorField.Label',
+  'Table',
+  'Table.Col',
+  'TextAreaInput',
+  'TextField',
+  'TextInput',
+]);
+
+// List of translatable props
+const DEFAULT_TRANSLATABLE_PROPS = new Set([
+  'label',
+  'title',
+  'placeholder',
+  'emptyText',
+  'helperText',
+  'description',
+  'successMessage',
+  'errorMessage',
+]);
+
+interface Config {
+  components?: string[];
+  translatableProps?: string[];
+}
+
+function loadConfig(configPath?: string): { components: Set<string>; translatableProps: Set<string> } {
+  const components = new Set(DEFAULT_STRATO_COMPONENTS);
+  const translatableProps = new Set(DEFAULT_TRANSLATABLE_PROPS);
+
+  const resolvedConfigPath = configPath || path.join(process.cwd(), 'strato-i18n.config.json');
+
+  if (fs.existsSync(resolvedConfigPath)) {
+    try {
+      const config: Config = JSON.parse(fs.readFileSync(resolvedConfigPath, 'utf8'));
+
+      if (config.components) {
+        config.components.forEach((c) => components.add(c));
+      }
+      if (config.translatableProps) {
+        config.translatableProps.forEach((p) => translatableProps.add(p));
+      }
+      console.log(`Loaded configuration from ${resolvedConfigPath}`);
+    } catch (e: any) {
+      console.error(`Failed to parse configuration file at ${resolvedConfigPath}:`, e.message);
+    }
+  }
+
+  return { components, translatableProps };
+}
+
+function getJSXElementName(node: t.JSXOpeningElement['name']): string {
+  if (t.isJSXIdentifier(node)) {
+    return node.name;
+  }
+  if (t.isJSXMemberExpression(node)) {
+    return `${getJSXElementName(node.object)}.${node.property.name}`;
+  }
+  if (t.isJSXNamespacedName(node)) {
+    return `${node.namespace.name}:${node.name.name}`;
+  }
+  return '';
+}
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  let format: string | undefined = undefined;
+  let config: string | undefined = undefined;
+  const positionalArgs: string[] = [];
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--format' && i + 1 < args.length) {
+      format = args[i + 1];
+      i++;
+    } else if (args[i].startsWith('--format=')) {
+      format = args[i].split('=')[1];
+    } else if (args[i] === '--config' && i + 1 < args.length) {
+      config = args[i + 1];
+      i++;
+    } else if (args[i].startsWith('--config=')) {
+      config = args[i].split('=')[1];
+    } else {
+      positionalArgs.push(args[i]);
+    }
+  }
+
+  const srcPattern = positionalArgs[0] || 'src/**/*.{ts,tsx}';
+  let outDir = 'locales';
+  let localeArgs: string[] = [];
+
+  if (positionalArgs.length > 1) {
+    if (positionalArgs[1].includes('*')) {
+      // First target is a glob, so we treat ALL subsequent args as targets
+      outDir = '.';
+      localeArgs = positionalArgs.slice(1);
+    } else {
+      // First target is a directory
+      outDir = positionalArgs[1];
+      localeArgs = positionalArgs.slice(2);
+      if (localeArgs.length === 0) {
+        localeArgs = ['en'];
+      }
+    }
+  } else {
+    localeArgs = ['en'];
+  }
+
+  return { srcPattern, outDir, localeArgs, format, config };
+}
+
+function main() {
+  const { srcPattern, outDir, localeArgs, format: formatArg, config: configPath } = parseArgs();
+  const { components, translatableProps } = loadConfig(configPath);
+
+  console.log(`Extracting messages from ${srcPattern} (using Babel)...`);
+
+  const files = globSync(srcPattern, { absolute: true });
+  const extractedMessages = new Set<string>();
+
+  files.forEach((file) => {
+    try {
+      const content = fs.readFileSync(file, 'utf8');
+      const ast = parse(content, {
+        sourceType: 'module',
+        plugins: ['typescript', 'jsx', 'decorators-legacy'],
+      });
+
+      traverse(ast, {
+        JSXOpeningElement(path) {
+          const tagName = getJSXElementName(path.node.name);
+
+          const baseNameMatch =
+            components.has(tagName) || Array.from(components).some((c) => tagName.startsWith(c + '.') || tagName === c);
+
+          if (baseNameMatch) {
+            path.node.attributes.forEach((attr) => {
+              if (t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name) && translatableProps.has(attr.name.name)) {
+                let textValue: string | null = null;
+
+                if (attr.value) {
+                  if (t.isStringLiteral(attr.value)) {
+                    textValue = attr.value.value;
+                  } else if (t.isJSXExpressionContainer(attr.value)) {
+                    const expr = attr.value.expression;
+                    if (t.isStringLiteral(expr) || t.isTemplateLiteral(expr)) {
+                      if (t.isStringLiteral(expr)) {
+                        textValue = expr.value;
+                      } else if (expr.quasis.length === 1) {
+                        textValue = expr.quasis[0].value.raw;
+                      }
+                    }
+                  }
+                }
+
+                if (textValue && textValue.trim() !== '') {
+                  extractedMessages.add(textValue);
+                }
+              }
+            });
+          }
+        },
+      });
+    } catch (e: any) {
+      console.error(`Failed to parse ${file}:`, e.message);
+    }
+  });
+
+  console.log(`Found ${extractedMessages.size} translatable strings.`);
+
+  const targets: { outFile: string; locale: string; format: string }[] = [];
+
+  localeArgs.forEach((arg) => {
+    if (arg.includes('*')) {
+      const matchedFiles = globSync(arg, { absolute: true });
+      matchedFiles.forEach((file) => {
+        const ext = path.extname(file).slice(1);
+        const format = formatArg || (ext === 'po' ? 'po' : 'json');
+
+        // Guess locale from path: locales/en.po -> en, locales/en/messages.po -> en
+        let locale = path.basename(file, '.' + ext);
+        if (locale === 'messages' || locale === 'translations' || locale === 'LC_MESSAGES') {
+          const parts = file.split(path.sep);
+          locale = parts[parts.length - 2];
+        }
+        targets.push({ outFile: file, locale, format });
+      });
+    } else {
+      let outFile: string;
+      let locale: string;
+      let format: string;
+
+      if (arg.includes('.') || arg.includes('/') || arg.includes('\\')) {
+        outFile = arg;
+        const ext = path.extname(arg).slice(1);
+        format = formatArg || (ext === 'po' ? 'po' : 'json');
+
+        locale = path.basename(arg, '.' + ext);
+        if (locale === 'messages' || locale === 'translations' || locale === 'LC_MESSAGES') {
+          const parts = path.resolve(arg).split(path.sep);
+          locale = parts[parts.length - 2];
+        }
+      } else {
+        format = formatArg || 'json';
+        const extension = format === 'po' ? 'po' : 'json';
+        outFile = path.join(outDir, `${arg}.${extension}`);
+        locale = arg;
+      }
+      targets.push({ outFile, locale, format });
+    }
+  });
+
+  if (targets.length === 0) {
+    console.error('No target files found or specified.');
+    process.exit(1);
+  }
+
+  targets.forEach(({ outFile, locale, format }) => {
+    let existingTranslations: Record<string, { defaultMessage: string; translation: string }> = {};
+
+    if (fs.existsSync(outFile)) {
+      try {
+        if (format === 'po') {
+          const fileContent = fs.readFileSync(outFile);
+          const parsedPo = gettextParser.po.parse(fileContent);
+
+          Object.entries(parsedPo.translations).forEach(([context, entries]) => {
+            Object.entries(entries).forEach(([msgid, data]: [string, any]) => {
+              if (msgid === '') return;
+
+              // Find the hash: check context (v2), then comment (v3), then msgid (v1)
+              const commentHash = data.comments?.extracted?.match(/id: (\w+)/)?.[1];
+              const hash = context || commentHash || msgid;
+
+              existingTranslations[hash] = {
+                defaultMessage: data.msgid || data.comments?.extracted || '',
+                translation: data.msgstr[0] || '',
+              };
+            });
+          });
+        } else {
+          existingTranslations = JSON.parse(fs.readFileSync(outFile, 'utf8'));
+        }
+      } catch (e: any) {
+        console.error(`Failed to parse existing translation file at ${outFile}:`, e.message);
+        return; // Skip this file
+      }
+    } else {
+      const parentDir = path.dirname(outFile);
+      if (!fs.existsSync(parentDir)) {
+        fs.mkdirSync(parentDir, { recursive: true });
+      }
+    }
+
+    const updatedTranslations: Record<string, { defaultMessage: string; translation: string }> = {};
+    let addedCount = 0;
+
+    extractedMessages.forEach((msg) => {
+      const msgid = generateMessageId(msg);
+      if (existingTranslations[msgid]) {
+        updatedTranslations[msgid] = { ...existingTranslations[msgid] };
+        updatedTranslations[msgid].defaultMessage = msg;
+      } else {
+        updatedTranslations[msgid] = {
+          defaultMessage: msg,
+          translation: '',
+        };
+        addedCount++;
+      }
+    });
+
+    Object.keys(existingTranslations).forEach((key) => {
+      if (!updatedTranslations[key]) {
+        updatedTranslations[key] = existingTranslations[key];
+      }
+    });
+
+    if (format === 'po') {
+      const poData: any = {
+        charset: 'utf-8',
+        headers: {
+          'content-type': 'text/plain; charset=utf-8',
+          language: locale,
+        },
+        translations: {
+          '': {
+            '': { msgid: '', msgstr: [''] }, // Header
+          },
+        },
+      };
+
+      Object.entries(updatedTranslations).forEach(([hash, data]) => {
+        poData.translations[''][data.defaultMessage] = {
+          msgid: data.defaultMessage,
+          msgstr: [data.translation],
+          comments: {
+            extracted: `id: ${hash}`,
+          },
+        };
+      });
+
+      const compiledPo = gettextParser.po.compile(poData);
+      fs.writeFileSync(outFile, compiledPo);
+    } else {
+      fs.writeFileSync(outFile, JSON.stringify(updatedTranslations, null, 2));
+    }
+
+    console.log(`Updated ${outFile} (${locale}): Added ${addedCount} new messages.`);
+  });
+}
+
+if (require.main === module) {
+  main();
+}

package/src/i18n/extracted-messages.json

@@ -0,0 +1,28 @@
+{
+  "ra.action.add": {
+    "defaultMessage": "Add",
+    "description": "Label for the button to add a new record"
+  },
+  "ra.action.add_filter": {
+    "defaultMessage": "Add filter"
+  },
+  "ra.action.cancel": {
+    "defaultMessage": "Cancel"
+  },
+  "ra.action.delete": {
+    "defaultMessage": "Delete"
+  },
+  "ra.action.edit": {
+    "defaultMessage": "Edit"
+  },
+  "ra.action.remove_filter": {
+    "defaultMessage": "Remove filter"
+  },
+  "ra.action.save": {
+    "defaultMessage": "Save",
+    "description": "Label for the button to save a record"
+  },
+  "ra.action.search": {
+    "defaultMessage": "Search"
+  }
+}