@babelize/engine 0.0.0-stage → 0.1.2

package/dist/modules/finalization/writes.js

@@ -0,0 +1,78 @@
+"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.FinalizationWriter = void 0;
+const path = __importStar(require("path"));
+const file_utils_1 = require("../../utils/file-utils");
+/**
+ * The single path every finalization write goes through.
+ *
+ * Hosts ship `changes` with the run (the GitHub PR, the ZIP, the CLI report),
+ * so a write that bypasses this recorder is a file the PR silently leaves out:
+ * `t()` calls merged without the dependency or the init code that makes them
+ * work. Records new files as well as edits, and folds repeated writes to one
+ * file into a single change (first original, last content).
+ */
+class FinalizationWriter {
+    constructor(root, dryRun) {
+        this.root = root;
+        this.dryRun = dryRun;
+        this.byFile = new Map();
+    }
+    /** Write `content` to `absPath` (unless dry run) and record it. Returns false when the file already had that content. */
+    async write(absPath, content) {
+        const original = (await (0, file_utils_1.pathExists)(absPath)) ? await (0, file_utils_1.readFile)(absPath) : null;
+        if (original === content)
+            return false;
+        if (!this.dryRun)
+            await (0, file_utils_1.writeFile)(absPath, content);
+        this.record(absPath, original, content);
+        return true;
+    }
+    /** Record a write made elsewhere (e.g. by a package manager). `original` null = file was created. */
+    record(absPath, original, content) {
+        const file = path.relative(this.root, path.resolve(absPath)).split(path.sep).join('/');
+        const prev = this.byFile.get(file);
+        if (prev) {
+            prev.modifiedContent = content;
+            return;
+        }
+        this.byFile.set(file, { file, originalContent: original ?? '', modifiedContent: content, created: original === null });
+    }
+    get changes() {
+        return [...this.byFile.values()];
+    }
+}
+exports.FinalizationWriter = FinalizationWriter;

package/dist/modules/format-injection/index.d.ts

@@ -0,0 +1,19 @@
+import type { ExtractedString, FileInjection, SkippedFile, WorkspaceInfo } from '../../runtime/types';
+import type { FormatLocaleConfig } from '@babelize/types';
+export interface FormatInjectionResult {
+    modifiedFiles: FileInjection[];
+    skippedFiles: SkippedFile[];
+    totalInjections: number;
+}
+/**
+ * Run format injection for all format strings.
+ *
+ * Replaces hardcoded currency, date, and number values in source files
+ * with Intl.* API calls (e.g., Intl.NumberFormat, Intl.DateTimeFormat).
+ */
+export declare function injectFormats(workspace: WorkspaceInfo, formatStrings: ExtractedString[], formatConfig: FormatLocaleConfig, dryRun?: boolean): Promise<FormatInjectionResult>;
+/**
+ * Filter format strings out of an array of extracted strings.
+ * Returns [translatableStrings, formatStrings].
+ */
+export declare function partitionFormatStrings(strings: ExtractedString[]): [translatable: ExtractedString[], format: ExtractedString[]];

package/dist/modules/format-injection/index.js

@@ -0,0 +1,273 @@
+"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.injectFormats = injectFormats;
+exports.partitionFormatStrings = partitionFormatStrings;
+const path = __importStar(require("path"));
+const t = __importStar(require("@babel/types"));
+const inject_formats_1 = require("./inject-formats");
+const ast_helpers_1 = require("../../utils/ast-helpers");
+const file_utils_1 = require("../../utils/file-utils");
+const types_1 = require("../../runtime/types");
+const generator_1 = require("@babel/generator");
+/**
+ * Run format injection for all format strings.
+ *
+ * Replaces hardcoded currency, date, and number values in source files
+ * with Intl.* API calls (e.g., Intl.NumberFormat, Intl.DateTimeFormat).
+ */
+async function injectFormats(workspace, formatStrings, formatConfig, dryRun = false) {
+    const modifiedFiles = [];
+    const skippedFiles = [];
+    let totalInjections = 0;
+    if (!formatConfig.enabled || formatStrings.length === 0) {
+        return { modifiedFiles, skippedFiles, totalInjections: 0 };
+    }
+    // Group format strings by file
+    const stringsByFile = new Map();
+    for (const s of formatStrings) {
+        if (!s.detectedFormat)
+            continue;
+        const fileKey = s.file;
+        if (!stringsByFile.has(fileKey)) {
+            stringsByFile.set(fileKey, []);
+        }
+        stringsByFile.get(fileKey).push(s);
+    }
+    // Build locale expression based on framework
+    const localeExpr = (0, inject_formats_1.buildLocaleExpression)(workspace.framework || 'unknown');
+    // Find all source files
+    const sourceFiles = [];
+    for (const sourceDir of workspace.sourceDirs) {
+        const dirPath = path.join(workspace.path, sourceDir);
+        const files = await (0, file_utils_1.findFiles)(dirPath, types_1.SUPPORTED_EXTENSIONS, types_1.EXCLUDED_PATTERNS);
+        sourceFiles.push(...files);
+    }
+    // Build a lookup of format strings by (relative file path, line)
+    const formatStringLookup = new Map();
+    for (const [fileKey, strings] of stringsByFile) {
+        const lineMap = new Map();
+        for (const s of strings) {
+            lineMap.set(s.line, s);
+        }
+        formatStringLookup.set(fileKey, lineMap);
+    }
+    // Process each file
+    for (const filePath of sourceFiles) {
+        const relativePath = (0, file_utils_1.getRelativePath)(workspace.path, filePath);
+        const fileStrings = stringsByFile.get(relativePath);
+        if (!fileStrings || fileStrings.length === 0)
+            continue;
+        try {
+            const originalContent = await (0, file_utils_1.readFile)(filePath);
+            const isTypeScript = filePath.endsWith('.ts') || filePath.endsWith('.tsx');
+            const ast = (0, ast_helpers_1.parseCode)(originalContent, { isTypeScript });
+            const injections = [];
+            const lineLookup = formatStringLookup.get(relativePath);
+            if (!lineLookup)
+                continue;
+            // Walk AST and replace matching string literals with Intl.* expressions
+            (0, ast_helpers_1.traverse)(ast, {
+                StringLiteral(strPath) {
+                    const node = strPath.node;
+                    if (!node.loc)
+                        return;
+                    const line = node.loc.start.line;
+                    const formatStr = lineLookup.get(line);
+                    if (!formatStr || !formatStr.detectedFormat)
+                        return;
+                    // Verify the text matches exactly (avoid false positives from partial matches)
+                    if (node.value !== formatStr.text)
+                        return;
+                    const astExpr = (0, inject_formats_1.buildFormatAstExpression)(formatStr.detectedFormat, formatConfig, localeExpr);
+                    if (!astExpr) {
+                        skippedFiles.push({
+                            file: relativePath,
+                            reason: 'format-ast-build-failed',
+                            details: `Could not build AST for: "${formatStr.text}"`,
+                        });
+                        return;
+                    }
+                    strPath.replaceWith(astExpr);
+                    const replacementCode = (0, generator_1.generate)(astExpr).code;
+                    injections.push({
+                        file: relativePath,
+                        line,
+                        column: node.loc.start.column,
+                        original: formatStr.text,
+                        replacement: replacementCode,
+                        key: '',
+                        confidence: 100,
+                        formatClass: formatStr.detectedFormat.class,
+                    });
+                },
+                JSXText(jsxPath) {
+                    const node = jsxPath.node;
+                    if (!node.loc)
+                        return;
+                    const line = node.loc.start.line;
+                    const formatStr = lineLookup.get(line);
+                    if (!formatStr || !formatStr.detectedFormat)
+                        return;
+                    const text = node.value.trim();
+                    if (!text)
+                        return;
+                    const astExpr = (0, inject_formats_1.buildFormatAstExpression)(formatStr.detectedFormat, formatConfig, localeExpr);
+                    if (!astExpr) {
+                        skippedFiles.push({
+                            file: relativePath,
+                            reason: 'format-ast-build-failed',
+                            details: `Could not build AST for: "${formatStr.text}"`,
+                        });
+                        return;
+                    }
+                    const exprContainer = t.jsxExpressionContainer(astExpr);
+                    jsxPath.replaceWith(exprContainer);
+                    const replacementCode = (0, generator_1.generate)(astExpr).code;
+                    injections.push({
+                        file: relativePath,
+                        line,
+                        column: node.loc.start.column,
+                        original: formatStr.text,
+                        replacement: replacementCode,
+                        key: '',
+                        confidence: 100,
+                        formatClass: formatStr.detectedFormat.class,
+                    });
+                },
+            });
+            if (injections.length === 0)
+                continue;
+            const modifiedContent = (0, ast_helpers_1.generateCode)(ast, originalContent);
+            if (!dryRun) {
+                await (0, file_utils_1.writeFile)(filePath, modifiedContent);
+            }
+            modifiedFiles.push({
+                file: relativePath,
+                originalContent,
+                modifiedContent,
+                injections,
+                importAdded: false,
+                hookAdded: false,
+            });
+            totalInjections += injections.length;
+        }
+        catch (error) {
+            skippedFiles.push({
+                file: relativePath,
+                reason: 'parse-error',
+                details: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    // Process HTML files with regex-based format injection
+    const htmlExtensions = ['.html', '.htm'];
+    for (const sourceDir of workspace.sourceDirs) {
+        const dirPath = path.join(workspace.path, sourceDir);
+        const files = await (0, file_utils_1.findFiles)(dirPath, htmlExtensions, types_1.EXCLUDED_PATTERNS);
+        for (const filePath of files) {
+            const relativePath = (0, file_utils_1.getRelativePath)(workspace.path, filePath);
+            const fileStrings = stringsByFile.get(relativePath);
+            if (!fileStrings || fileStrings.length === 0)
+                continue;
+            try {
+                const originalContent = await (0, file_utils_1.readFile)(filePath);
+                let content = originalContent;
+                const injections = [];
+                for (const formatStr of fileStrings) {
+                    if (!formatStr.detectedFormat)
+                        continue;
+                    const escaped = formatStr.text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                    const regex = new RegExp(escaped, 'g');
+                    if (!regex.test(content))
+                        continue;
+                    const astExpr = (0, inject_formats_1.buildFormatAstExpression)(formatStr.detectedFormat, formatConfig, localeExpr);
+                    if (!astExpr)
+                        continue;
+                    const replacementCode = (0, generator_1.generate)(astExpr).code;
+                    content = content.replace(regex, replacementCode);
+                    injections.push({
+                        file: relativePath,
+                        line: formatStr.line,
+                        column: 0,
+                        original: formatStr.text,
+                        replacement: replacementCode,
+                        key: '',
+                        confidence: 100,
+                        formatClass: formatStr.detectedFormat.class,
+                    });
+                }
+                if (injections.length === 0)
+                    continue;
+                if (!dryRun)
+                    await (0, file_utils_1.writeFile)(filePath, content);
+                modifiedFiles.push({
+                    file: relativePath,
+                    originalContent,
+                    modifiedContent: content,
+                    injections,
+                    importAdded: false,
+                    hookAdded: false,
+                });
+                totalInjections += injections.length;
+            }
+            catch (error) {
+                skippedFiles.push({
+                    file: relativePath,
+                    reason: 'parse-error',
+                    details: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    }
+    return { modifiedFiles, skippedFiles, totalInjections };
+}
+/**
+ * Filter format strings out of an array of extracted strings.
+ * Returns [translatableStrings, formatStrings].
+ */
+function partitionFormatStrings(strings) {
+    const translatable = [];
+    const format = [];
+    for (const s of strings) {
+        if (s.context === 'format-string' && s.detectedFormat) {
+            format.push(s);
+        }
+        else {
+            translatable.push(s);
+        }
+    }
+    return [translatable, format];
+}

package/dist/modules/format-injection/inject-formats.d.ts

@@ -0,0 +1,31 @@
+import * as t from '@babel/types';
+import type { FormatLocaleConfig } from '@babelize/types';
+import type { DetectedFormat, ExtractedString } from '../../runtime/types';
+/**
+ * Generate the Intl.* API call string that replaces a hardcoded format value.
+ *
+ * Examples:
+ *   "$1,234.56" → `new Intl.NumberFormat(locale, { style: 'currency', currency: 'USD' }).format(1234.56)`
+ *   "01/15/2024" → `new Intl.DateTimeFormat(locale, { month: '2-digit', day: '2-digit', year: 'numeric' }).format(new Date(2024, 0, 15))`
+ *   "1,234.56" → `new Intl.NumberFormat(locale).format(1234.56)`
+ */
+export declare function generateFormatExpression(format: DetectedFormat, formatConfig: FormatLocaleConfig): string | null;
+/**
+ * Given a locale and DetectedFormat, return both the Intl.* expression
+ * and a getTranslationKey-compatible fallback string.
+ */
+export interface FormatInjection {
+    expression: string;
+    fallback: string;
+}
+export declare function buildFormatInjection(extracted: ExtractedString, formatConfig: FormatLocaleConfig): FormatInjection | null;
+/**
+ * Build a Babel AST Expression node for the Intl.* call that replaces
+ * a hardcoded format value. The localeExpr parameter provides the runtime
+ * locale expression (e.g., i18n.language, navigator.language).
+ */
+export declare function buildFormatAstExpression(format: DetectedFormat, formatConfig: FormatLocaleConfig, localeExpr: t.Expression): t.Expression | null;
+/**
+ * Build a locale expression based on the detected framework.
+ */
+export declare function buildLocaleExpression(framework: string): t.Expression;

package/dist/modules/format-injection/inject-formats.js

@@ -0,0 +1,208 @@
+"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.generateFormatExpression = generateFormatExpression;
+exports.buildFormatInjection = buildFormatInjection;
+exports.buildFormatAstExpression = buildFormatAstExpression;
+exports.buildLocaleExpression = buildLocaleExpression;
+const t = __importStar(require("@babel/types"));
+/**
+ * Generate the Intl.* API call string that replaces a hardcoded format value.
+ *
+ * Examples:
+ *   "$1,234.56" → `new Intl.NumberFormat(locale, { style: 'currency', currency: 'USD' }).format(1234.56)`
+ *   "01/15/2024" → `new Intl.DateTimeFormat(locale, { month: '2-digit', day: '2-digit', year: 'numeric' }).format(new Date(2024, 0, 15))`
+ *   "1,234.56" → `new Intl.NumberFormat(locale).format(1234.56)`
+ */
+function generateFormatExpression(format, formatConfig) {
+    switch (format.class) {
+        case 'currency':
+            return generateCurrencyExpression(format, formatConfig);
+        case 'date':
+            return generateDateExpression(format, formatConfig);
+        case 'number':
+            return generateNumberExpression(format, formatConfig);
+        default:
+            return null;
+    }
+}
+function generateCurrencyExpression(format, formatConfig) {
+    const currencyCode = format.detectedCurrency || formatConfig.currency?.code || 'USD';
+    const numericValue = parseNumericValue(format.rawValue);
+    if (isNaN(numericValue)) {
+        return JSON.stringify(format.originalString);
+    }
+    return `new Intl.NumberFormat(locale, { style: 'currency', currency: '${currencyCode}' }).format(${numericValue})`;
+}
+function generateDateExpression(format, _formatConfig) {
+    const date = parseDateValue(format.rawValue, format.dateSource);
+    if (!date) {
+        return JSON.stringify(format.originalString);
+    }
+    const dateOptions = format.dateOptions || { year: 'numeric', month: '2-digit', day: '2-digit' };
+    const dateOptionsStr = JSON.stringify(dateOptions);
+    return `new Intl.DateTimeFormat(locale, ${dateOptionsStr}).format(new Date(${date.getTime()}))`;
+}
+function generateNumberExpression(format, _formatConfig) {
+    const numericValue = parseNumericValue(format.rawValue);
+    if (isNaN(numericValue)) {
+        return JSON.stringify(format.originalString);
+    }
+    const options = { ...format.numberOptions };
+    return `new Intl.NumberFormat(locale, ${JSON.stringify(options)}).format(${numericValue})`;
+}
+function parseNumericValue(rawValue) {
+    const cleaned = rawValue.replace(/[^0-9.,-]/g, '');
+    const normalized = cleaned.replace(/,/g, '');
+    return parseFloat(normalized);
+}
+function parseDateValue(rawValue, source) {
+    // Remove ordinal suffixes like "th", "nd", "st", "rd"
+    const cleaned = rawValue.replace(/(\d+)(st|nd|rd|th)/, '$1');
+    switch (source) {
+        case 'MM/DD/YYYY': {
+            const parts = cleaned.split(/[/]/);
+            if (parts.length !== 3)
+                return null;
+            return new Date(parseInt(parts[2]), parseInt(parts[0]) - 1, parseInt(parts[1]));
+        }
+        case 'DD/MM/YYYY': {
+            const parts = cleaned.split(/[/]/);
+            if (parts.length !== 3)
+                return null;
+            return new Date(parseInt(parts[2]), parseInt(parts[1]) - 1, parseInt(parts[0]));
+        }
+        case 'YYYY-MM-DD': {
+            const parts = cleaned.split(/[-/]/);
+            if (parts.length !== 3)
+                return null;
+            return new Date(parseInt(parts[0]), parseInt(parts[1]) - 1, parseInt(parts[2]));
+        }
+        case 'DD.MM.YYYY': {
+            const parts = cleaned.split('.');
+            if (parts.length !== 3)
+                return null;
+            return new Date(parseInt(parts[2]), parseInt(parts[1]) - 1, parseInt(parts[0]));
+        }
+        case 'MMM DD, YYYY': {
+            return new Date(cleaned);
+        }
+        case 'DD MMM YYYY': {
+            return new Date(cleaned);
+        }
+        default: {
+            return new Date(cleaned);
+        }
+    }
+}
+function buildFormatInjection(extracted, formatConfig) {
+    if (!extracted.detectedFormat)
+        return null;
+    const expression = generateFormatExpression(extracted.detectedFormat, formatConfig);
+    if (!expression)
+        return null;
+    return {
+        expression,
+        fallback: extracted.text,
+    };
+}
+/**
+ * Build a Babel AST Expression node for the Intl.* call that replaces
+ * a hardcoded format value. The localeExpr parameter provides the runtime
+ * locale expression (e.g., i18n.language, navigator.language).
+ */
+function buildFormatAstExpression(format, formatConfig, localeExpr) {
+    switch (format.class) {
+        case 'currency':
+            return buildCurrencyAstExpression(format, formatConfig, localeExpr);
+        case 'date':
+            return buildDateAstExpression(format, localeExpr);
+        case 'number':
+            return buildNumberAstExpression(format, localeExpr);
+        default:
+            return null;
+    }
+}
+function buildCurrencyAstExpression(format, formatConfig, localeExpr) {
+    const currencyCode = format.detectedCurrency || formatConfig.currency?.code || 'USD';
+    const numericValue = parseNumericValue(format.rawValue);
+    if (isNaN(numericValue))
+        return null;
+    const intlCallee = t.memberExpression(t.identifier('Intl'), t.identifier('NumberFormat'));
+    const options = t.objectExpression([
+        t.objectProperty(t.identifier('style'), t.stringLiteral('currency')),
+        t.objectProperty(t.identifier('currency'), t.stringLiteral(currencyCode)),
+    ]);
+    const nfNew = t.newExpression(intlCallee, [localeExpr, options]);
+    return t.callExpression(t.memberExpression(nfNew, t.identifier('format')), [t.numericLiteral(numericValue)]);
+}
+function buildDateAstExpression(format, localeExpr) {
+    const date = parseDateValue(format.rawValue, format.dateSource);
+    if (!date)
+        return null;
+    const dateOptions = format.dateOptions || { year: 'numeric', month: '2-digit', day: '2-digit' };
+    const props = Object.entries(dateOptions).map(([key, val]) => t.objectProperty(t.identifier(key), t.stringLiteral(val)));
+    const intlCallee = t.memberExpression(t.identifier('Intl'), t.identifier('DateTimeFormat'));
+    const dtfNew = t.newExpression(intlCallee, [localeExpr, t.objectExpression(props)]);
+    const dateArg = t.newExpression(t.identifier('Date'), [t.numericLiteral(date.getTime())]);
+    return t.callExpression(t.memberExpression(dtfNew, t.identifier('format')), [dateArg]);
+}
+function buildNumberAstExpression(format, localeExpr) {
+    const numericValue = parseNumericValue(format.rawValue);
+    if (isNaN(numericValue))
+        return null;
+    const intlCallee = t.memberExpression(t.identifier('Intl'), t.identifier('NumberFormat'));
+    const args = [localeExpr];
+    const options = { ...format.numberOptions };
+    if (Object.keys(options).length > 0) {
+        const props = Object.entries(options).map(([key, val]) => t.objectProperty(t.identifier(key), t.numericLiteral(val)));
+        args.push(t.objectExpression(props));
+    }
+    const nfNew = t.newExpression(intlCallee, args);
+    return t.callExpression(t.memberExpression(nfNew, t.identifier('format')), [t.numericLiteral(numericValue)]);
+}
+/**
+ * Build a locale expression based on the detected framework.
+ */
+function buildLocaleExpression(framework) {
+    switch (framework) {
+        case 'react-i18next':
+            return t.memberExpression(t.identifier('i18n'), t.identifier('language'));
+        case 'next-intl':
+            return t.callExpression(t.identifier('useLocale'), []);
+        default:
+            return t.logicalExpression('||', t.memberExpression(t.identifier('navigator'), t.identifier('language')), t.stringLiteral('en-US'));
+    }
+}

package/dist/modules/glossary/index.d.ts

@@ -0,0 +1,2 @@
+export { canonicalLocale, canonicalizeLocaleKeys, conflictNotes, containsTerm, EMPTY_GLOSSARY, fixedTermsFor, glossaryFingerprint, hasFixedTerm, localeValue, normalizeGlossary, sourceHasTerm, termPattern, type GlossaryRuleInput, type GlossaryRules, } from './rules';
+export type { GlossaryEntry, GlossaryEntryType, BrandVoice, AlwaysTranslateAsEntry } from './types';

package/dist/modules/glossary/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.termPattern = exports.sourceHasTerm = exports.normalizeGlossary = exports.localeValue = exports.hasFixedTerm = exports.glossaryFingerprint = exports.fixedTermsFor = exports.EMPTY_GLOSSARY = exports.containsTerm = exports.conflictNotes = exports.canonicalizeLocaleKeys = exports.canonicalLocale = void 0;
+var rules_1 = require("./rules");
+Object.defineProperty(exports, "canonicalLocale", { enumerable: true, get: function () { return rules_1.canonicalLocale; } });
+Object.defineProperty(exports, "canonicalizeLocaleKeys", { enumerable: true, get: function () { return rules_1.canonicalizeLocaleKeys; } });
+Object.defineProperty(exports, "conflictNotes", { enumerable: true, get: function () { return rules_1.conflictNotes; } });
+Object.defineProperty(exports, "containsTerm", { enumerable: true, get: function () { return rules_1.containsTerm; } });
+Object.defineProperty(exports, "EMPTY_GLOSSARY", { enumerable: true, get: function () { return rules_1.EMPTY_GLOSSARY; } });
+Object.defineProperty(exports, "fixedTermsFor", { enumerable: true, get: function () { return rules_1.fixedTermsFor; } });
+Object.defineProperty(exports, "glossaryFingerprint", { enumerable: true, get: function () { return rules_1.glossaryFingerprint; } });
+Object.defineProperty(exports, "hasFixedTerm", { enumerable: true, get: function () { return rules_1.hasFixedTerm; } });
+Object.defineProperty(exports, "localeValue", { enumerable: true, get: function () { return rules_1.localeValue; } });
+Object.defineProperty(exports, "normalizeGlossary", { enumerable: true, get: function () { return rules_1.normalizeGlossary; } });
+Object.defineProperty(exports, "sourceHasTerm", { enumerable: true, get: function () { return rules_1.sourceHasTerm; } });
+Object.defineProperty(exports, "termPattern", { enumerable: true, get: function () { return rules_1.termPattern; } });