@strato-admin/i18n-cli 0.1.1 → 0.3.0

package/dist/extract.js

@@ -0,0 +1,558 @@
+#!/usr/bin/env node
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const glob_1 = require("glob");
+const parser_1 = require("@babel/parser");
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const t = __importStar(require("@babel/types"));
+const gettextParser = __importStar(require("gettext-parser"));
+const i18n_1 = require("@strato-admin/i18n");
+const minimatch_1 = require("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([
+    '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',
+    'listLabel',
+    'createLabel',
+    'editLabel',
+    'detailLabel',
+    'title',
+    'listTitle',
+    'createTitle',
+    'editTitle',
+    'detailTitle',
+    'placeholder',
+    'emptyText',
+    'helperText',
+    'description',
+    'listDescription',
+    'createDescription',
+    'editDescription',
+    'detailDescription',
+    'saveButtonLabel',
+    '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;
+    let outFile = undefined;
+    let locale = undefined;
+    const ignorePatterns = [];
+    const positionalArgs = [];
+    for (let i = 0; i < args.length; i++) {
+        if ((args[i] === '--format' || args[i] === '-f') && 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 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]);
+        }
+    }
+    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, outFile, ignorePatterns, locale };
+}
+function main() {
+    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(', ')}`);
+    }
+    let files = (0, glob_1.globSync)(srcPattern, { absolute: true });
+    if (ignorePatterns.length > 0) {
+        files = files.filter((file) => {
+            const relativeFile = path.relative(process.cwd(), file);
+            const isIgnored = ignorePatterns.some((pattern) => (0, minimatch_1.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();
+    const addExtractedMessage = (msgid, msgctxt, location, translatorComment, precomputedHash) => {
+        const normalizedMsgid = (0, i18n_1.normalizeMessage)(msgid);
+        const prettyMsgid = (0, i18n_1.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 {
+            const content = fs.readFileSync(file, 'utf8');
+            const ast = (0, parser_1.parse)(content, {
+                sourceType: 'module',
+                plugins: ['typescript', 'jsx', 'decorators-legacy'],
+            });
+            const relativeFile = path.relative(process.cwd(), file);
+            (0, traverse_1.default)(ast, {
+                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 = 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 = 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) {
+                        p.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.cooked || expr.quasis[0].value.raw;
+                                            }
+                                        }
+                                    }
+                                }
+                                if (textValue && textValue.trim() !== '') {
+                                    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 = 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;
+                    let msgctxt;
+                    let translatorComment;
+                    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;
+                    if (explicitId) {
+                        precomputedHash = explicitId;
+                        msgctxt = undefined; // id supersedes context; no msgctxt in PO
+                    }
+                    else if (msgctxt) {
+                        precomputedHash = (0, i18n_1.generateMessageId)(`${msgctxt}\x04${(0, i18n_1.normalizeMessage)(textValue)}`);
+                    }
+                    const line = p.node.loc?.start.line || 0;
+                    addExtractedMessage(textValue, msgctxt, `${relativeFile}:${line}`, translatorComment, precomputedHash);
+                },
+            });
+        }
+        catch (e) {
+            console.error(`Failed to parse ${file}:`, e.message);
+        }
+    });
+    console.log(`Found ${extractedMessages.size} translatable strings.`);
+    const targets = [];
+    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 = (0, glob_1.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((data) => {
+            const hash = data.precomputedHash ?? (data.msgctxt ? data.msgctxt : (0, i18n_1.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[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]) {
+                const existing = existingTranslations[key];
+                updatedTranslations[key] = {
+                    defaultMessage: existing.defaultMessage || '',
+                    translation: existing.translation || '',
+                };
+            }
+        });
+        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]) => {
+                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'),
+                    },
+                };
+            });
+            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.`);
+    });
+}
+main();

package/dist/strato-i18n/src/formatter.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Pretty-prints an ICU message for better readability in translation files.
+ * Uses newlines and indentation for nested structures.
+ */
+export declare function prettyPrintICU(msg: string): string;
+/**
+ * Canonicalizes an ICU message using the official printer and normalization.
+ * This ensures consistent spacing and a single-line format for hashing and compilation.
+ */
+export declare function canonicalizeMessage(msg: string): string;

package/dist/strato-i18n/src/formatter.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettyPrintICU = prettyPrintICU;
+exports.canonicalizeMessage = canonicalizeMessage;
+const icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
+const printer_js_1 = require("@formatjs/icu-messageformat-parser/printer.js");
+const hash_1 = require("./hash");
+/**
+ * Pretty-prints an ICU message for better readability in translation files.
+ * Uses newlines and indentation for nested structures.
+ */
+function prettyPrintICU(msg) {
+    try {
+        const ast = (0, icu_messageformat_parser_1.parse)(msg);
+        return printElement(ast, 0).trim();
+    }
+    catch (e) {
+        return msg.trim();
+    }
+}
+function printElement(elements, indent) {
+    const padding = '  '.repeat(indent);
+    let result = '';
+    elements.forEach((el) => {
+        if ((0, icu_messageformat_parser_1.isLiteralElement)(el)) {
+            result += el.value;
+        }
+        else if ((0, icu_messageformat_parser_1.isPluralElement)(el) || (0, icu_messageformat_parser_1.isSelectElement)(el)) {
+            const type = (0, icu_messageformat_parser_1.isPluralElement)(el) ? 'plural' : 'select';
+            result += `{${el.value}, ${type},\n`;
+            const options = Object.entries(el.options);
+            options.forEach(([key, opt], _) => {
+                result += `${padding}  ${key} {${printElement(opt.value, indent + 2)}}\n`;
+            });
+            result += `${padding}}`;
+        }
+        else if ((0, icu_messageformat_parser_1.isTagElement)(el)) {
+            result += `<${el.value}>${printElement(el.children, indent)}</${el.value}>`;
+        }
+        else if ((0, icu_messageformat_parser_1.isPoundElement)(el)) {
+            result += '#';
+        }
+        else {
+            // For arguments like {name}
+            result += `{${el.value || ''}}`;
+        }
+    });
+    return result;
+}
+/**
+ * Canonicalizes an ICU message using the official printer and normalization.
+ * This ensures consistent spacing and a single-line format for hashing and compilation.
+ */
+function canonicalizeMessage(msg) {
+    try {
+        const ast = (0, icu_messageformat_parser_1.parse)(msg);
+        return (0, hash_1.normalizeMessage)((0, printer_js_1.printAST)(ast));
+    }
+    catch (e) {
+        return (0, hash_1.normalizeMessage)(msg);
+    }
+}

package/dist/strato-i18n/src/hash.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Simple FNV-1a hash for generating stable message IDs.
+ * This is lightweight and works identically in Node and the Browser.
+ */
+export declare function generateMessageId(msg: string): string;
+/**
+ * Normalizes a message string by collapsing multiple whitespaces and newlines.
+ * This ensures that formatting changes in the source code do not change the message ID.
+ */
+export declare function normalizeMessage(msg: string): string;

package/dist/strato-i18n/src/hash.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMessageId = generateMessageId;
+exports.normalizeMessage = normalizeMessage;
+/**
+ * Simple FNV-1a hash for generating stable message IDs.
+ * This is lightweight and works identically in Node and the Browser.
+ */
+function generateMessageId(msg) {
+    const normalized = normalizeMessage(msg);
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < normalized.length; i++) {
+        hash ^= normalized.charCodeAt(i);
+        // FNV-1a prime multiplication (hash * 16777619)
+        hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+    }
+    // Convert to a base36 string for a compact, stable ID
+    return (hash >>> 0).toString(36);
+}
+/**
+ * Normalizes a message string by collapsing multiple whitespaces and newlines.
+ * This ensures that formatting changes in the source code do not change the message ID.
+ */
+function normalizeMessage(msg) {
+    return msg.replace(/\s+/g, ' ').trim();
+}

package/dist/strato-i18n/src/icuI18nProvider.d.ts

@@ -0,0 +1,2 @@
+import type { I18nProvider } from '@strato-admin/ra-core';
+export declare const icuI18nProvider: (getMessages: (locale: string) => any | Promise<any>, initialLocale?: string, availableLocales?: any[]) => I18nProvider;