@scoutello/i18n-magic/dist/commands/create-pruned-namespace-automated.js

Intelligent CLI toolkit that automates internationalization workflows with AI-powered translations for JavaScript/TypeScript projects

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.createPrunedNamespaceAutomated = void 0;
const fast_glob_1 = __importDefault(require("fast-glob"));
const i18next_scanner_1 = require("i18next-scanner");
const node_fs_1 = __importDefault(require("node:fs"));
const utils_1 = require("../lib/utils");
const createPrunedNamespaceAutomated = async (config, options) => {
    const { namespaces, loadPath, savePath, locales, defaultNamespace } = config;
    const { sourceNamespace, newNamespace, globPatterns } = options;
    // Validate inputs
    if (!namespaces.includes(sourceNamespace)) {
        throw new Error(`Source namespace '${sourceNamespace}' not found in configuration`);
    }
    if (namespaces.includes(newNamespace)) {
        throw new Error(`Namespace '${newNamespace}' already exists`);
    }
    console.log(`Creating pruned namespace '${newNamespace}' from '${sourceNamespace}'`);
    console.log(`Using glob patterns: ${globPatterns.join(", ")}`);
    // Extract keys from files matching the glob patterns
    const parser = new i18next_scanner_1.Parser({
        nsSeparator: false,
        keySeparator: false,
    });
    const files = await (0, fast_glob_1.default)([...globPatterns, "!**/node_modules/**"]);
    console.log(`Found ${files.length} files to scan`);
    const extractedKeys = [];
    for (const file of files) {
        const content = node_fs_1.default.readFileSync(file, "utf-8");
        parser.parseFuncFromString(content, { list: ["t"] }, (key) => {
            extractedKeys.push(key);
        });
    }
    const uniqueExtractedKeys = (0, utils_1.removeDuplicatesFromArray)(extractedKeys);
    console.log(`Found ${uniqueExtractedKeys.length} unique translation keys`);
    // Filter keys that belong to the source namespace
    const relevantKeys = [];
    for (const key of uniqueExtractedKeys) {
        const pureKey = (0, utils_1.getPureKey)(key, sourceNamespace, sourceNamespace === defaultNamespace);
        if (pureKey) {
            relevantKeys.push(pureKey);
        }
    }
    console.log(`Found ${relevantKeys.length} keys from namespace '${sourceNamespace}'`);
    if (relevantKeys.length === 0) {
        console.log("No relevant keys found. Exiting...");
        return {
            success: false,
            message: "No relevant keys found",
            keysCount: 0,
        };
    }
    // Get translations from source namespace and create new namespace files
    const results = [];
    for (const locale of locales) {
        try {
            // Load source namespace translations
            const sourceTranslations = await (0, utils_1.loadLocalesFile)(loadPath, locale, sourceNamespace);
            // Create new namespace with only the keys used in the glob pattern files
            const newNamespaceTranslations = {};
            for (const key of relevantKeys) {
                if (sourceTranslations[key]) {
                    newNamespaceTranslations[key] = sourceTranslations[key];
                }
            }
            // Write the new namespace file
            await (0, utils_1.writeLocalesFile)(savePath, locale, newNamespace, newNamespaceTranslations);
            const keyCount = Object.keys(newNamespaceTranslations).length;
            console.log(`Created pruned namespace '${newNamespace}' for locale '${locale}' with ${keyCount} keys`);
            results.push({
                locale,
                keyCount,
                success: true,
            });
        }
        catch (error) {
            console.error(`Error creating pruned namespace for locale '${locale}':`, error);
            results.push({
                locale,
                keyCount: 0,
                success: false,
                error: error instanceof Error ? error.message : String(error),
            });
        }
    }
    console.log(`✅ Successfully created pruned namespace '${newNamespace}'`);
    return {
        success: true,
        message: `Created pruned namespace '${newNamespace}' with ${relevantKeys.length} keys`,
        keysCount: relevantKeys.length,
        results,
    };
};
exports.createPrunedNamespaceAutomated = createPrunedNamespaceAutomated;
//# sourceMappingURL=create-pruned-namespace-automated.js.map