@strato-admin/i18n-cli 0.1.0 → 0.3.0

package/src/cli/compile.ts

@@ -3,22 +3,44 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { globSync } from 'glob';
 import * as gettextParser from 'gettext-parser';
+import { normalizeMessage } from '@strato-admin/i18n';
 
-function main() {
+function parseArgs() {
   const args = process.argv.slice(2);
-  const pattern = args[0] || 'locales';
+  let outFile: string | undefined = undefined;
+  const positionalArgs: string[] = [];
+
+  for (let i = 0; i < args.length; i++) {
+    if ((args[i] === '--out-file' || args[i] === '-o') && i + 1 < args.length) {
+      outFile = args[i + 1];
+      i++;
+    } else if (args[i].startsWith('--out-file=')) {
+      outFile = args[i].split('=')[1];
+    } else {
+      positionalArgs.push(args[i]);
+    }
+  }
+
+  const pattern = positionalArgs[0] || 'locales';
+  return { pattern, outFile };
+}
+
+function main() {
+  const { pattern, outFile: explicitOutFile } = parseArgs();
 
   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));
+    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'));
+    files = globSync(pattern, { absolute: true }).filter(
+      (file) => (file.endsWith('.json') || file.endsWith('.po')) && !file.endsWith('.compiled.json'),
+    );
   }
 
   if (files.length === 0) {
@@ -26,29 +48,37 @@ function main() {
     return;
   }
 
+  // If explicitOutFile is provided, we only expect ONE input file or we combine them?
+  // FormatJS compile behavior: formatjs compile <file> --out-file <outFile>
+  if (explicitOutFile && files.length > 1) {
+    console.warn(`Warning: Multiple input files found but only one --out-file specified. Using the first one.`);
+    files = [files[0]];
+  }
+
   let processedCount = 0;
 
-  files.forEach(filePath => {
-    const compiledFilePath = filePath.replace(/\.(json|po)$/, '.compiled.json');
+  files.forEach((filePath) => {
+    const compiledFilePath = explicitOutFile || filePath.replace(/\.(json|po)$/, '.compiled.json');
     const fileName = path.basename(filePath);
 
-    let translations: Record<string, { defaultMessage: string, translation: string }> = {};
+    let translations: Record<string, any> = {};
 
     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;
+
+            // Find the hash: #. id: comment is authoritative (covers explicit ids and
+            // context-mangled hashes); fall back to msgctxt, then raw msgid.
+            const commentHash = data.comments?.extracted?.match(/id: (\S+)/)?.[1];
+            const hash = commentHash || context || msgid;
 
             translations[hash] = {
               defaultMessage: data.msgid || data.comments?.extracted || '',
-              translation: data.msgstr[0] || ''
+              translation: data.msgstr[0] || '',
             };
           });
         });
@@ -61,24 +91,34 @@ function main() {
     }
 
     const compiledMapping: Record<string, string> = {};
+    const sortedKeys = Object.keys(translations).sort();
 
-    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;
+    sortedKeys.forEach((hash) => {
+      const data = translations[hash];
+      // Support both strato-i18n-cli format and formatjs format (with translation or defaultMessage as translation)
+      if (typeof data === 'string') {
+        compiledMapping[hash] = normalizeMessage(data);
+      } else if (data.translation && data.translation.trim() !== '') {
+        compiledMapping[hash] = normalizeMessage(data.translation);
       } else {
-        compiledMapping[msgid] = data.defaultMessage;
+        // Fallback to defaultMessage
+        compiledMapping[hash] = normalizeMessage(data.defaultMessage || '');
       }
     });
 
+    const parentDir = path.dirname(compiledFilePath);
+    if (!fs.existsSync(parentDir)) {
+      fs.mkdirSync(parentDir, { recursive: true });
+    }
+
     fs.writeFileSync(compiledFilePath, JSON.stringify(compiledMapping, null, 2));
-    console.log(`Compiled ${fileName} -> ${path.basename(compiledFilePath)} (${Object.keys(compiledMapping).length} messages)`);
+    console.log(
+      `Compiled ${fileName} -> ${path.basename(compiledFilePath)} (${Object.keys(compiledMapping).length} messages)`,
+    );
     processedCount++;
   });
 
   console.log(`Successfully compiled ${processedCount} files.`);
 }
 
-if (require.main === module) {
-  main();
-}
+main();

package/src/cli/extract.ts

@@ -6,7 +6,11 @@ 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';
+import { generateMessageId, normalizeMessage, prettyPrintICU } from '@strato-admin/i18n';
+import { minimatch } from 'minimatch';
+
+// Components whose JSX children text is the translatable string (source-as-key)
+const CHILDREN_AS_KEY_COMPONENTS = new Set(['Message', 'RecordMessage']);
 
 // List of Strato Admin components to extract from
 const DEFAULT_STRATO_COMPONENTS = new Set([
@@ -44,11 +48,24 @@ const DEFAULT_STRATO_COMPONENTS = new Set([
 // List of translatable props
 const DEFAULT_TRANSLATABLE_PROPS = new Set([
   'label',
+  'listLabel',
+  'createLabel',
+  'editLabel',
+  'detailLabel',
   'title',
+  'listTitle',
+  'createTitle',
+  'editTitle',
+  'detailTitle',
   'placeholder',
   'emptyText',
   'helperText',
   'description',
+  'listDescription',
+  'createDescription',
+  'editDescription',
+  'detailDescription',
+  'saveButtonLabel',
   'successMessage',
   'errorMessage',
 ]);
@@ -100,10 +117,13 @@ function parseArgs() {
   const args = process.argv.slice(2);
   let format: string | undefined = undefined;
   let config: string | undefined = undefined;
+  let outFile: string | undefined = undefined;
+  let locale: string | undefined = undefined;
+  const ignorePatterns: string[] = [];
   const positionalArgs: string[] = [];
 
   for (let i = 0; i < args.length; i++) {
-    if (args[i] === '--format' && i + 1 < args.length) {
+    if ((args[i] === '--format' || args[i] === '-f') && i + 1 < args.length) {
       format = args[i + 1];
       i++;
     } else if (args[i].startsWith('--format=')) {
@@ -113,6 +133,21 @@ function parseArgs() {
       i++;
     } else if (args[i].startsWith('--config=')) {
       config = args[i].split('=')[1];
+    } else if ((args[i] === '--out-file' || args[i] === '-o') && i + 1 < args.length) {
+      outFile = args[i + 1];
+      i++;
+    } else if (args[i].startsWith('--out-file=')) {
+      outFile = args[i].split('=')[1];
+    } else if ((args[i] === '--locale' || args[i] === '-l') && i + 1 < args.length) {
+      locale = args[i + 1];
+      i++;
+    } else if (args[i].startsWith('--locale=')) {
+      locale = args[i].split('=')[1];
+    } else if ((args[i] === '--ignore' || args[i] === '-i') && i + 1 < args.length) {
+      ignorePatterns.push(args[i + 1]);
+      i++;
+    } else if (args[i].startsWith('--ignore=')) {
+      ignorePatterns.push(args[i].split('=')[1]);
     } else {
       positionalArgs.push(args[i]);
     }
@@ -139,17 +174,77 @@ function parseArgs() {
     localeArgs = ['en'];
   }
 
-  return { srcPattern, outDir, localeArgs, format, config };
+  return { srcPattern, outDir, localeArgs, format, config, outFile, ignorePatterns, locale };
+}
+
+interface ExtractedMessage {
+  msgid: string;
+  msgctxt?: string;
+  /** Pre-computed hash or explicit id, written to `#. id:` and used as the compiled JSON key. */
+  precomputedHash?: string;
+  locations: Set<string>;
+  translatorComment?: string;
 }
 
 function main() {
-  const { srcPattern, outDir, localeArgs, format: formatArg, config: configPath } = parseArgs();
+  const {
+    srcPattern,
+    outDir,
+    localeArgs,
+    format: formatArg,
+    config: configPath,
+    outFile: explicitOutFile,
+    ignorePatterns,
+    locale: explicitLocale,
+  } = parseArgs();
   const { components, translatableProps } = loadConfig(configPath);
 
   console.log(`Extracting messages from ${srcPattern} (using Babel)...`);
+  if (ignorePatterns.length > 0) {
+    console.log(`Ignoring patterns: ${ignorePatterns.join(', ')}`);
+  }
 
-  const files = globSync(srcPattern, { absolute: true });
-  const extractedMessages = new Set<string>();
+  let files = globSync(srcPattern, { absolute: true });
+
+  if (ignorePatterns.length > 0) {
+    files = files.filter((file) => {
+      const relativeFile = path.relative(process.cwd(), file);
+      const isIgnored = ignorePatterns.some((pattern) => minimatch(relativeFile, pattern));
+      return !isIgnored;
+    });
+  }
+
+  console.log(`Processing ${files.length} files...`);
+  if (files.length < 10) {
+    console.log('Files:', files);
+  } else {
+    console.log('Sample files:', files.slice(0, 5));
+  }
+
+  const extractedMessages = new Map<string, ExtractedMessage>();
+
+  const addExtractedMessage = (
+    msgid: string,
+    msgctxt: string | undefined,
+    location: string,
+    translatorComment?: string,
+    precomputedHash?: string,
+  ) => {
+    const normalizedMsgid = normalizeMessage(msgid);
+    const prettyMsgid = prettyPrintICU(msgid);
+    const key = precomputedHash ? `hash:${precomputedHash}` : msgctxt ? `ctx:${msgctxt}` : `msg:${normalizedMsgid}`;
+
+    if (!extractedMessages.has(key)) {
+      extractedMessages.set(key, {
+        msgid: prettyMsgid,
+        msgctxt,
+        precomputedHash,
+        locations: new Set(),
+        translatorComment,
+      });
+    }
+    extractedMessages.get(key)!.locations.add(location);
+  };
 
   files.forEach((file) => {
     try {
@@ -159,15 +254,62 @@ function main() {
         plugins: ['typescript', 'jsx', 'decorators-legacy'],
       });
 
+      const relativeFile = path.relative(process.cwd(), file);
+
       traverse(ast, {
-        JSXOpeningElement(path) {
-          const tagName = getJSXElementName(path.node.name);
+        CallExpression(p) {
+          const { callee, arguments: args } = p.node;
+          if (
+            t.isIdentifier(callee) &&
+            (callee.name === 'translate' || callee.name === 'translateLabel') &&
+            args.length > 0
+          ) {
+            const firstArg = args[0];
+            let firstArgValue: string | null = null;
+            if (t.isStringLiteral(firstArg)) {
+              firstArgValue = firstArg.value;
+            } else if (t.isTemplateLiteral(firstArg) && firstArg.quasis.length === 1) {
+              firstArgValue = firstArg.quasis[0].value.cooked || firstArg.quasis[0].value.raw;
+            }
+
+            if (firstArgValue) {
+              let msgid = firstArgValue;
+              let msgctxt: string | undefined = undefined;
+
+              // Check for second argument { _: "Default Text" }
+              if (args.length > 1) {
+                const secondArg = args[1];
+                if (t.isObjectExpression(secondArg)) {
+                  const defaultProp = secondArg.properties.find((prop) => {
+                    const isMatch = t.isObjectProperty(prop) && t.isIdentifier(prop.key) && prop.key.name === '_';
+                    return isMatch;
+                  });
+                  if (defaultProp && t.isObjectProperty(defaultProp)) {
+                    if (t.isStringLiteral(defaultProp.value)) {
+                      msgid = defaultProp.value.value;
+                      msgctxt = firstArgValue; // The first arg is the explicit ID
+                    } else if (t.isTemplateLiteral(defaultProp.value) && defaultProp.value.quasis.length === 1) {
+                      msgid = defaultProp.value.quasis[0].value.cooked || defaultProp.value.quasis[0].value.raw;
+                      msgctxt = firstArgValue;
+                    }
+                  }
+                }
+              }
+
+              const line = p.node.loc?.start.line || 0;
+              const location = `${relativeFile}:${line}`;
+              addExtractedMessage(msgid, msgctxt, location);
+            }
+          }
+        },
+        JSXOpeningElement(p) {
+          const tagName = getJSXElementName(p.node.name);
 
           const baseNameMatch =
             components.has(tagName) || Array.from(components).some((c) => tagName.startsWith(c + '.') || tagName === c);
 
           if (baseNameMatch) {
-            path.node.attributes.forEach((attr) => {
+            p.node.attributes.forEach((attr) => {
               if (t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name) && translatableProps.has(attr.name.name)) {
                 let textValue: string | null = null;
 
@@ -180,19 +322,71 @@ function main() {
                       if (t.isStringLiteral(expr)) {
                         textValue = expr.value;
                       } else if (expr.quasis.length === 1) {
-                        textValue = expr.quasis[0].value.raw;
+                        textValue = expr.quasis[0].value.cooked || expr.quasis[0].value.raw;
                       }
                     }
                   }
                 }
 
                 if (textValue && textValue.trim() !== '') {
-                  extractedMessages.add(textValue);
+                  const line = attr.loc?.start.line || 0;
+                  const location = `${relativeFile}:${line}`;
+                  addExtractedMessage(textValue, undefined, location);
                 }
               }
             });
           }
         },
+        JSXElement(p) {
+          const tagName = getJSXElementName(p.node.openingElement.name);
+          if (!CHILDREN_AS_KEY_COMPONENTS.has(tagName)) return;
+
+          // Extract text from children: JSXText or StringLiteral in JSXExpressionContainer
+          let textValue: string | null = null;
+          for (const child of p.node.children) {
+            if (t.isJSXText(child) && child.value.trim()) {
+              textValue = child.value.trim();
+              break;
+            }
+            if (t.isJSXExpressionContainer(child) && t.isStringLiteral(child.expression)) {
+              textValue = child.expression.value;
+              break;
+            }
+          }
+          if (!textValue) return;
+
+          // Extract id, context, and comment from opening element attributes
+          let explicitId: string | undefined;
+          let msgctxt: string | undefined;
+          let translatorComment: string | undefined;
+          for (const attr of p.node.openingElement.attributes) {
+            if (!t.isJSXAttribute(attr) || !t.isJSXIdentifier(attr.name)) continue;
+            const val = t.isStringLiteral(attr.value)
+              ? attr.value.value
+              : t.isJSXExpressionContainer(attr.value) && t.isStringLiteral(attr.value.expression)
+                ? attr.value.expression.value
+                : undefined;
+            if (val === undefined) continue;
+            if (attr.name.name === 'id') explicitId = val;
+            if (attr.name.name === 'context') msgctxt = val;
+            if (attr.name.name === 'comment') translatorComment = val;
+          }
+
+          // Compute the hash written to `#. id:` and used as the compiled JSON key:
+          //   id present   → literal id (e.g. "action.archive"), no msgctxt
+          //   context only → hash(context + \x04 + message), msgctxt = context
+          //   neither      → hash(message), no msgctxt
+          let precomputedHash: string | undefined;
+          if (explicitId) {
+            precomputedHash = explicitId;
+            msgctxt = undefined; // id supersedes context; no msgctxt in PO
+          } else if (msgctxt) {
+            precomputedHash = generateMessageId(`${msgctxt}\x04${normalizeMessage(textValue)}`);
+          }
+
+          const line = p.node.loc?.start.line || 0;
+          addExtractedMessage(textValue, msgctxt, `${relativeFile}:${line}`, translatorComment, precomputedHash);
+        },
       });
     } catch (e: any) {
       console.error(`Failed to parse ${file}:`, e.message);
@@ -203,45 +397,51 @@ function main() {
 
   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];
-        }
+  if (explicitOutFile) {
+    const ext = path.extname(explicitOutFile).slice(1);
+    const format = formatArg || (ext === 'po' ? 'po' : 'json');
+    targets.push({ outFile: explicitOutFile, locale: explicitLocale || 'en', format });
+  } else {
+    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 {
-        format = formatArg || 'json';
-        const extension = format === 'po' ? 'po' : 'json';
-        outFile = path.join(outDir, `${arg}.${extension}`);
-        locale = arg;
+        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 });
       }
-      targets.push({ outFile, locale, format });
-    }
-  });
+    });
+  }
 
   if (targets.length === 0) {
     console.error('No target files found or specified.');
@@ -249,7 +449,7 @@ function main() {
   }
 
   targets.forEach(({ outFile, locale, format }) => {
-    let existingTranslations: Record<string, { defaultMessage: string; translation: string }> = {};
+    let existingTranslations: Record<string, any> = {};
 
     if (fs.existsSync(outFile)) {
       try {
@@ -285,26 +485,49 @@ function main() {
       }
     }
 
-    const updatedTranslations: Record<string, { defaultMessage: string; translation: string }> = {};
+    const updatedTranslations: Record<
+      string,
+      {
+        defaultMessage: string;
+        translation: string;
+        locations?: string[];
+        msgctxt?: string;
+        translatorComment?: string;
+      }
+    > = {};
     let addedCount = 0;
 
-    extractedMessages.forEach((msg) => {
-      const msgid = generateMessageId(msg);
-      if (existingTranslations[msgid]) {
-        updatedTranslations[msgid] = { ...existingTranslations[msgid] };
-        updatedTranslations[msgid].defaultMessage = msg;
+    extractedMessages.forEach((data) => {
+      const hash = data.precomputedHash ?? (data.msgctxt ? data.msgctxt : generateMessageId(data.msgid));
+      if (existingTranslations[hash]) {
+        const existing = existingTranslations[hash];
+        updatedTranslations[hash] = {
+          defaultMessage: data.msgid,
+          translation: existing.translation || (existing.description ? '' : ''),
+          locations: Array.from(data.locations),
+          msgctxt: data.msgctxt,
+          translatorComment: data.translatorComment,
+        };
       } else {
-        updatedTranslations[msgid] = {
-          defaultMessage: msg,
+        updatedTranslations[hash] = {
+          defaultMessage: data.msgid,
           translation: '',
+          locations: Array.from(data.locations),
+          msgctxt: data.msgctxt,
+          translatorComment: data.translatorComment,
         };
         addedCount++;
       }
     });
 
+    // Keep hardcoded keys (like ra.*)
     Object.keys(existingTranslations).forEach((key) => {
       if (!updatedTranslations[key]) {
-        updatedTranslations[key] = existingTranslations[key];
+        const existing = existingTranslations[key];
+        updatedTranslations[key] = {
+          defaultMessage: existing.defaultMessage || '',
+          translation: existing.translation || '',
+        };
       }
     });
 
@@ -323,11 +546,26 @@ function main() {
       };
 
       Object.entries(updatedTranslations).forEach(([hash, data]) => {
-        poData.translations[''][data.defaultMessage] = {
+        const context = data.msgctxt || '';
+        if (!poData.translations[context]) {
+          poData.translations[context] = {};
+        }
+
+        // To achieve multi-line PO visual without \n, we must ensure the strings
+        // themselves don't have newlines before gettext-parser sees them.
+        // However, we WANT the structured look.
+        // If we want gettext-parser to wrap, we usually can't control it.
+        // Instead, we will use our previously successful "compiledPo.replace" approach
+        // but with a better regex that actually works on the serialized output.
+
+        poData.translations[context][data.defaultMessage] = {
           msgid: data.defaultMessage,
+          msgctxt: data.msgctxt ? data.msgctxt : undefined,
           msgstr: [data.translation],
           comments: {
+            ...(data.translatorComment ? { translator: data.translatorComment } : {}),
             extracted: `id: ${hash}`,
+            reference: data.locations?.join('\n'),
           },
         };
       });
@@ -342,6 +580,4 @@ function main() {
   });
 }
 
-if (require.main === module) {
-  main();
-}
+main();

package/src/i18n/extracted-messages.json

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