@windrun-huaiin/dev-scripts 6.8.2 → 6.9.1

package/dist/commands/check-translations.js

@@ -0,0 +1,132 @@
+'use strict';
+
+var logger = require('../utils/logger.js');
+var fileScanner = require('../utils/file-scanner.js');
+var translationParser = require('../utils/translation-parser.js');
+
+async function checkTranslations(config, cwd = typeof process !== 'undefined' ? process.cwd() : '.') {
+    const logger$1 = new logger.Logger(config);
+    logger$1.warn('==============================');
+    logger$1.warn(`‼️  Current working directory: ⭕  ${cwd}  ⭕`);
+    logger$1.warn('==============================');
+    try {
+        logger$1.log('start checking translations...');
+        // scan all files
+        const scanResults = await fileScanner.scanFiles(config, cwd);
+        logger$1.log(`found ${scanResults.length} files to scan`);
+        // load translation files
+        const translations = fileScanner.loadTranslations(config, cwd);
+        // collect used translation keys and namespaces
+        const foundTranslationKeys = new Set();
+        const foundNamespaces = new Set();
+        // scan all files, extract translation information
+        for (const { filePath, content } of scanResults) {
+            try {
+                const { namespaces, keys } = translationParser.extractTranslationsInfo(content, filePath);
+                if (keys.length > 0 || namespaces.size > 0) {
+                    logger$1.log(`found the following information in the file ${filePath}:`);
+                    if (namespaces.size > 0) {
+                        logger$1.log(`  translation function mapping:`);
+                        namespaces.forEach((namespace, varName) => {
+                            logger$1.log(`    - ${varName} => ${namespace}`);
+                            foundNamespaces.add(namespace);
+                        });
+                    }
+                    if (keys.length > 0) {
+                        logger$1.log(`  translation keys:`);
+                        keys.forEach(key => {
+                            logger$1.log(`    - ${key}`);
+                            foundTranslationKeys.add(key);
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    logger$1.error(`error processing file ${filePath}: ${error.message}`);
+                }
+                else {
+                    logger$1.error(`error processing file ${filePath}: unknown error`);
+                }
+            }
+        }
+        logger$1.log(`\nfound ${foundNamespaces.size} used namespaces in the code: ${Array.from(foundNamespaces).join(', ')}`);
+        // check results
+        const report = {};
+        // check if the namespace exists
+        foundNamespaces.forEach(namespace => {
+            config.i18n.locales.forEach(locale => {
+                const missingNamespaceKey = `missingNamespacesIn${locale.toUpperCase()}`;
+                if (!translationParser.checkNamespaceExists(namespace, translations[locale])) {
+                    report[missingNamespaceKey] = report[missingNamespaceKey] || [];
+                    report[missingNamespaceKey].push(namespace);
+                }
+            });
+        });
+        // check if the translation key exists
+        foundTranslationKeys.forEach(key => {
+            config.i18n.locales.forEach(locale => {
+                const missingKey = `missingIn${locale.toUpperCase()}`;
+                if (!translationParser.checkKeyExists(key, translations[locale])) {
+                    report[missingKey] = report[missingKey] || [];
+                    report[missingKey].push(key);
+                }
+            });
+        });
+        // check if the translation keys are consistent
+        config.i18n.locales.forEach(locale => {
+            const allKeys = translationParser.getAllKeys(translations[locale]);
+            config.i18n.locales.forEach(otherLocale => {
+                if (locale !== otherLocale) {
+                    const otherKeys = translationParser.getAllKeys(translations[otherLocale]);
+                    const onlyKeys = `${locale}OnlyKeys`;
+                    report[onlyKeys] = allKeys.filter(key => !otherKeys.includes(key));
+                }
+            });
+        });
+        // generate report
+        logger$1.log('\n=== translation check report ===\n');
+        // first report missing namespaces, which is usually the most serious problem
+        config.i18n.locales.forEach(locale => {
+            const missingNamespaceKey = `missingNamespacesIn${locale.toUpperCase()}`;
+            if (report[missingNamespaceKey]?.length > 0) {
+                logger$1.log(`🚨 missing namespaces in the ${locale} translation file:`);
+                report[missingNamespaceKey].forEach(namespace => logger$1.log(`  - ${namespace}`));
+            }
+            else {
+                logger$1.success(`${locale} translation file has all used namespaces`);
+            }
+        });
+        // then report missing translation keys
+        config.i18n.locales.forEach(locale => {
+            const missingKey = `missingIn${locale.toUpperCase()}`;
+            if (report[missingKey]?.length > 0) {
+                logger$1.log(`\n🔴 missing keys in the ${locale} translation file:`);
+                report[missingKey].forEach(key => logger$1.log(`  - ${key}`));
+            }
+            else {
+                logger$1.success(`${locale} translation file has all used keys`);
+            }
+        });
+        // finally report inconsistent keys
+        config.i18n.locales.forEach(locale => {
+            const onlyKeys = `${locale}OnlyKeys`;
+            if (report[onlyKeys]?.length > 0) {
+                logger$1.log(`\n⚠️ keys only exist in the ${locale} translation file:`);
+                report[onlyKeys].forEach(key => logger$1.log(`  - ${key}`));
+            }
+        });
+        logger$1.log('\n=== report end ===\n');
+        logger$1.log("⚠️⚠️⚠️script depends on regular matching, for multiple translation namespaces in a single file, use naming to distinguish: t1 | t2 | t3 | ... ⚠️⚠️⚠️");
+        // save log file
+        logger$1.saveToFile('check.log', cwd);
+        // if there are any problems, return non-zero status code
+        return Object.values(report).some(keys => keys.length > 0) ? 1 : 0;
+    }
+    catch (error) {
+        logger$1.error(`error checking translations: ${error}`);
+        return 1;
+    }
+}
+
+exports.checkTranslations = checkTranslations;

package/dist/commands/check-translations.mjs

@@ -0,0 +1,130 @@
+import { Logger } from '../utils/logger.mjs';
+import { scanFiles, loadTranslations } from '../utils/file-scanner.mjs';
+import { extractTranslationsInfo, checkNamespaceExists, checkKeyExists, getAllKeys } from '../utils/translation-parser.mjs';
+
+async function checkTranslations(config, cwd = typeof process !== 'undefined' ? process.cwd() : '.') {
+    const logger = new Logger(config);
+    logger.warn('==============================');
+    logger.warn(`‼️  Current working directory: ⭕  ${cwd}  ⭕`);
+    logger.warn('==============================');
+    try {
+        logger.log('start checking translations...');
+        // scan all files
+        const scanResults = await scanFiles(config, cwd);
+        logger.log(`found ${scanResults.length} files to scan`);
+        // load translation files
+        const translations = loadTranslations(config, cwd);
+        // collect used translation keys and namespaces
+        const foundTranslationKeys = new Set();
+        const foundNamespaces = new Set();
+        // scan all files, extract translation information
+        for (const { filePath, content } of scanResults) {
+            try {
+                const { namespaces, keys } = extractTranslationsInfo(content, filePath);
+                if (keys.length > 0 || namespaces.size > 0) {
+                    logger.log(`found the following information in the file ${filePath}:`);
+                    if (namespaces.size > 0) {
+                        logger.log(`  translation function mapping:`);
+                        namespaces.forEach((namespace, varName) => {
+                            logger.log(`    - ${varName} => ${namespace}`);
+                            foundNamespaces.add(namespace);
+                        });
+                    }
+                    if (keys.length > 0) {
+                        logger.log(`  translation keys:`);
+                        keys.forEach(key => {
+                            logger.log(`    - ${key}`);
+                            foundTranslationKeys.add(key);
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    logger.error(`error processing file ${filePath}: ${error.message}`);
+                }
+                else {
+                    logger.error(`error processing file ${filePath}: unknown error`);
+                }
+            }
+        }
+        logger.log(`\nfound ${foundNamespaces.size} used namespaces in the code: ${Array.from(foundNamespaces).join(', ')}`);
+        // check results
+        const report = {};
+        // check if the namespace exists
+        foundNamespaces.forEach(namespace => {
+            config.i18n.locales.forEach(locale => {
+                const missingNamespaceKey = `missingNamespacesIn${locale.toUpperCase()}`;
+                if (!checkNamespaceExists(namespace, translations[locale])) {
+                    report[missingNamespaceKey] = report[missingNamespaceKey] || [];
+                    report[missingNamespaceKey].push(namespace);
+                }
+            });
+        });
+        // check if the translation key exists
+        foundTranslationKeys.forEach(key => {
+            config.i18n.locales.forEach(locale => {
+                const missingKey = `missingIn${locale.toUpperCase()}`;
+                if (!checkKeyExists(key, translations[locale])) {
+                    report[missingKey] = report[missingKey] || [];
+                    report[missingKey].push(key);
+                }
+            });
+        });
+        // check if the translation keys are consistent
+        config.i18n.locales.forEach(locale => {
+            const allKeys = getAllKeys(translations[locale]);
+            config.i18n.locales.forEach(otherLocale => {
+                if (locale !== otherLocale) {
+                    const otherKeys = getAllKeys(translations[otherLocale]);
+                    const onlyKeys = `${locale}OnlyKeys`;
+                    report[onlyKeys] = allKeys.filter(key => !otherKeys.includes(key));
+                }
+            });
+        });
+        // generate report
+        logger.log('\n=== translation check report ===\n');
+        // first report missing namespaces, which is usually the most serious problem
+        config.i18n.locales.forEach(locale => {
+            const missingNamespaceKey = `missingNamespacesIn${locale.toUpperCase()}`;
+            if (report[missingNamespaceKey]?.length > 0) {
+                logger.log(`🚨 missing namespaces in the ${locale} translation file:`);
+                report[missingNamespaceKey].forEach(namespace => logger.log(`  - ${namespace}`));
+            }
+            else {
+                logger.success(`${locale} translation file has all used namespaces`);
+            }
+        });
+        // then report missing translation keys
+        config.i18n.locales.forEach(locale => {
+            const missingKey = `missingIn${locale.toUpperCase()}`;
+            if (report[missingKey]?.length > 0) {
+                logger.log(`\n🔴 missing keys in the ${locale} translation file:`);
+                report[missingKey].forEach(key => logger.log(`  - ${key}`));
+            }
+            else {
+                logger.success(`${locale} translation file has all used keys`);
+            }
+        });
+        // finally report inconsistent keys
+        config.i18n.locales.forEach(locale => {
+            const onlyKeys = `${locale}OnlyKeys`;
+            if (report[onlyKeys]?.length > 0) {
+                logger.log(`\n⚠️ keys only exist in the ${locale} translation file:`);
+                report[onlyKeys].forEach(key => logger.log(`  - ${key}`));
+            }
+        });
+        logger.log('\n=== report end ===\n');
+        logger.log("⚠️⚠️⚠️script depends on regular matching, for multiple translation namespaces in a single file, use naming to distinguish: t1 | t2 | t3 | ... ⚠️⚠️⚠️");
+        // save log file
+        logger.saveToFile('check.log', cwd);
+        // if there are any problems, return non-zero status code
+        return Object.values(report).some(keys => keys.length > 0) ? 1 : 0;
+    }
+    catch (error) {
+        logger.error(`error checking translations: ${error}`);
+        return 1;
+    }
+}
+
+export { checkTranslations };

package/dist/commands/clean-translations.d.ts

@@ -0,0 +1,3 @@
+import { DevScriptsConfig } from '@dev-scripts/config/schema';
+export declare function cleanTranslations(config: DevScriptsConfig, shouldRemove?: boolean, cwd?: string): Promise<number>;
+//# sourceMappingURL=clean-translations.d.ts.map

package/dist/commands/clean-translations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clean-translations.d.ts","sourceRoot":"","sources":["../../src/commands/clean-translations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAe7D,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,gBAAgB,EACxB,YAAY,GAAE,OAAe,EAC7B,GAAG,GAAE,MAA6D,GACjE,OAAO,CAAC,MAAM,CAAC,CAoKjB"}

package/dist/commands/clean-translations.js

@@ -0,0 +1,148 @@
+'use strict';
+
+var fileScanner = require('../utils/file-scanner.js');
+var logger = require('../utils/logger.js');
+var translationParser = require('../utils/translation-parser.js');
+var fs = require('fs');
+
+async function cleanTranslations(config, shouldRemove = false, cwd = typeof process !== 'undefined' ? process.cwd() : '.') {
+    const logger$1 = new logger.Logger(config);
+    const logFileName = shouldRemove ? 'remove.log' : 'clean.log';
+    logger$1.warn('==============================');
+    logger$1.warn(`‼️  Current working directory: ⭕  ${cwd}  ⭕`);
+    logger$1.warn('==============================');
+    try {
+        logger$1.log('start checking unused translation keys...');
+        // scan all files
+        const scanResults = await fileScanner.scanFiles(config, cwd);
+        logger$1.log(`找到 ${scanResults.length} 个文件需要扫描`);
+        // load translation files
+        const translations = fileScanner.loadTranslations(config, cwd);
+        // collect used translation keys and namespaces
+        const foundTranslationKeys = new Set();
+        const foundNamespaces = new Set();
+        // scan all files, collect used translation keys and namespaces
+        for (const { filePath, content } of scanResults) {
+            try {
+                const { namespaces, keys } = translationParser.extractTranslationsInfo(content, filePath);
+                if (keys.length > 0 || namespaces.size > 0) {
+                    logger$1.log(`found the following information in the file ${filePath}:`);
+                    if (namespaces.size > 0) {
+                        logger$1.log(`  translation function mapping:`);
+                        namespaces.forEach((namespace, varName) => {
+                            logger$1.log(`    - ${varName} => ${namespace}`);
+                            foundNamespaces.add(namespace);
+                        });
+                    }
+                    if (keys.length > 0) {
+                        logger$1.log(`  translation keys:`);
+                        keys.forEach(key => {
+                            logger$1.log(`    - ${key}`);
+                            foundTranslationKeys.add(key);
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    logger$1.error(`error processing file ${filePath}: ${error.message}`);
+                }
+                else {
+                    logger$1.error(`error processing file ${filePath}: unknown error`);
+                }
+            }
+        }
+        logger$1.log(`\nfound ${foundTranslationKeys.size} used translation keys in the code`);
+        logger$1.log(`found ${foundNamespaces.size} used namespaces in the code: ${Array.from(foundNamespaces).join(', ')}`);
+        // check unused keys in each language file
+        const unusedKeys = {};
+        const removedKeys = {};
+        const unusedNamespaces = {};
+        config.i18n.locales.forEach(locale => {
+            unusedKeys[locale] = [];
+            removedKeys[locale] = [];
+            unusedNamespaces[locale] = [];
+            // get all keys in the translation file
+            const allTranslationKeys = translationParser.getAllKeys(translations[locale]);
+            // get all namespaces (top-level keys) in the translation file
+            const allNamespaces = Object.keys(translations[locale] || {});
+            // find unused namespaces
+            allNamespaces.forEach(namespace => {
+                if (!foundNamespaces.has(namespace)) {
+                    unusedNamespaces[locale].push(namespace);
+                }
+            });
+            // find unused keys
+            allTranslationKeys.forEach(key => {
+                if (!foundTranslationKeys.has(key)) {
+                    unusedKeys[locale].push(key);
+                }
+            });
+            logger$1.log(`\nfound ${unusedKeys[locale].length} unused keys in the ${locale} translation file`);
+            logger$1.log(`found ${unusedNamespaces[locale].length} unused namespaces in the ${locale} translation file`);
+        });
+        if (shouldRemove) {
+            logger$1.log('\nstart deleting unused translation keys...');
+            // delete unused keys in each language file
+            config.i18n.locales.forEach(locale => {
+                const translationsCopy = { ...translations[locale] };
+                unusedKeys[locale].forEach(key => {
+                    if (translationParser.removeKeyFromTranslations(key, translationsCopy)) {
+                        removedKeys[locale].push(key);
+                    }
+                });
+                // delete unused namespaces
+                unusedNamespaces[locale].forEach(namespace => {
+                    if (translationsCopy[namespace] !== undefined) {
+                        delete translationsCopy[namespace];
+                        logger$1.log(`deleted unused namespace ${namespace} from the ${locale} translation file`);
+                    }
+                });
+                // clean empty objects
+                const cleanedTranslations = translationParser.cleanEmptyObjects(translationsCopy);
+                // save updated translation file
+                const filePath = fileScanner.getTranslationFilePath(locale, config, cwd);
+                fs.writeFileSync(filePath, JSON.stringify(cleanedTranslations, null, 2), 'utf8');
+                logger$1.log(`deleted ${removedKeys[locale].length} unused keys from the ${locale} translation file`);
+            });
+        }
+        else {
+            logger$1.log('\nTo delete unused keys, please run the script with the --remove parameter');
+        }
+        // generate report
+        logger$1.log('\n=== unused translation keys report ===\n');
+        config.i18n.locales.forEach(locale => {
+            if (unusedNamespaces[locale].length > 0) {
+                logger$1.log(`🔍 unused namespaces in the ${locale} translation file:`);
+                unusedNamespaces[locale].forEach(namespace => logger$1.log(`  - ${namespace}`));
+            }
+            else {
+                logger$1.success(`${locale} translation file has no unused namespaces`);
+            }
+            if (unusedKeys[locale].length > 0) {
+                logger$1.log(`\n🔍 unused keys in the ${locale} translation file:`);
+                unusedKeys[locale].forEach(key => logger$1.log(`  - ${key}`));
+            }
+            else {
+                logger$1.success(`${locale} translation file has no unused keys`);
+            }
+            if (shouldRemove && removedKeys[locale].length > 0) {
+                logger$1.log(`\n🗑️ deleted keys from the ${locale} translation file:`);
+                removedKeys[locale].forEach(key => logger$1.log(`  - ${key}`));
+            }
+        });
+        logger$1.log('\n=== report end ===\n');
+        logger$1.log("⚠️⚠️⚠️script depends on regular matching, for multiple translation namespaces in a single file, use naming to distinguish: t1 | t2 | t3 | ... ⚠️⚠️⚠️");
+        // save log file
+        logger$1.saveToFile(logFileName, cwd);
+        // if there are any unused keys or namespaces, return non-zero status code
+        return (Object.values(unusedKeys).some(keys => keys.length > 0) ||
+            Object.values(unusedNamespaces).some(namespaces => namespaces.length > 0)) ? 1 : 0;
+    }
+    catch (error) {
+        logger$1.error(`error cleaning translations: ${error}`);
+        return 1;
+    }
+}
+
+exports.cleanTranslations = cleanTranslations;

package/dist/commands/clean-translations.mjs

@@ -0,0 +1,146 @@
+import { scanFiles, loadTranslations, getTranslationFilePath } from '../utils/file-scanner.mjs';
+import { Logger } from '../utils/logger.mjs';
+import { extractTranslationsInfo, getAllKeys, removeKeyFromTranslations, cleanEmptyObjects } from '../utils/translation-parser.mjs';
+import { writeFileSync } from 'fs';
+
+async function cleanTranslations(config, shouldRemove = false, cwd = typeof process !== 'undefined' ? process.cwd() : '.') {
+    const logger = new Logger(config);
+    const logFileName = shouldRemove ? 'remove.log' : 'clean.log';
+    logger.warn('==============================');
+    logger.warn(`‼️  Current working directory: ⭕  ${cwd}  ⭕`);
+    logger.warn('==============================');
+    try {
+        logger.log('start checking unused translation keys...');
+        // scan all files
+        const scanResults = await scanFiles(config, cwd);
+        logger.log(`找到 ${scanResults.length} 个文件需要扫描`);
+        // load translation files
+        const translations = loadTranslations(config, cwd);
+        // collect used translation keys and namespaces
+        const foundTranslationKeys = new Set();
+        const foundNamespaces = new Set();
+        // scan all files, collect used translation keys and namespaces
+        for (const { filePath, content } of scanResults) {
+            try {
+                const { namespaces, keys } = extractTranslationsInfo(content, filePath);
+                if (keys.length > 0 || namespaces.size > 0) {
+                    logger.log(`found the following information in the file ${filePath}:`);
+                    if (namespaces.size > 0) {
+                        logger.log(`  translation function mapping:`);
+                        namespaces.forEach((namespace, varName) => {
+                            logger.log(`    - ${varName} => ${namespace}`);
+                            foundNamespaces.add(namespace);
+                        });
+                    }
+                    if (keys.length > 0) {
+                        logger.log(`  translation keys:`);
+                        keys.forEach(key => {
+                            logger.log(`    - ${key}`);
+                            foundTranslationKeys.add(key);
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    logger.error(`error processing file ${filePath}: ${error.message}`);
+                }
+                else {
+                    logger.error(`error processing file ${filePath}: unknown error`);
+                }
+            }
+        }
+        logger.log(`\nfound ${foundTranslationKeys.size} used translation keys in the code`);
+        logger.log(`found ${foundNamespaces.size} used namespaces in the code: ${Array.from(foundNamespaces).join(', ')}`);
+        // check unused keys in each language file
+        const unusedKeys = {};
+        const removedKeys = {};
+        const unusedNamespaces = {};
+        config.i18n.locales.forEach(locale => {
+            unusedKeys[locale] = [];
+            removedKeys[locale] = [];
+            unusedNamespaces[locale] = [];
+            // get all keys in the translation file
+            const allTranslationKeys = getAllKeys(translations[locale]);
+            // get all namespaces (top-level keys) in the translation file
+            const allNamespaces = Object.keys(translations[locale] || {});
+            // find unused namespaces
+            allNamespaces.forEach(namespace => {
+                if (!foundNamespaces.has(namespace)) {
+                    unusedNamespaces[locale].push(namespace);
+                }
+            });
+            // find unused keys
+            allTranslationKeys.forEach(key => {
+                if (!foundTranslationKeys.has(key)) {
+                    unusedKeys[locale].push(key);
+                }
+            });
+            logger.log(`\nfound ${unusedKeys[locale].length} unused keys in the ${locale} translation file`);
+            logger.log(`found ${unusedNamespaces[locale].length} unused namespaces in the ${locale} translation file`);
+        });
+        if (shouldRemove) {
+            logger.log('\nstart deleting unused translation keys...');
+            // delete unused keys in each language file
+            config.i18n.locales.forEach(locale => {
+                const translationsCopy = { ...translations[locale] };
+                unusedKeys[locale].forEach(key => {
+                    if (removeKeyFromTranslations(key, translationsCopy)) {
+                        removedKeys[locale].push(key);
+                    }
+                });
+                // delete unused namespaces
+                unusedNamespaces[locale].forEach(namespace => {
+                    if (translationsCopy[namespace] !== undefined) {
+                        delete translationsCopy[namespace];
+                        logger.log(`deleted unused namespace ${namespace} from the ${locale} translation file`);
+                    }
+                });
+                // clean empty objects
+                const cleanedTranslations = cleanEmptyObjects(translationsCopy);
+                // save updated translation file
+                const filePath = getTranslationFilePath(locale, config, cwd);
+                writeFileSync(filePath, JSON.stringify(cleanedTranslations, null, 2), 'utf8');
+                logger.log(`deleted ${removedKeys[locale].length} unused keys from the ${locale} translation file`);
+            });
+        }
+        else {
+            logger.log('\nTo delete unused keys, please run the script with the --remove parameter');
+        }
+        // generate report
+        logger.log('\n=== unused translation keys report ===\n');
+        config.i18n.locales.forEach(locale => {
+            if (unusedNamespaces[locale].length > 0) {
+                logger.log(`🔍 unused namespaces in the ${locale} translation file:`);
+                unusedNamespaces[locale].forEach(namespace => logger.log(`  - ${namespace}`));
+            }
+            else {
+                logger.success(`${locale} translation file has no unused namespaces`);
+            }
+            if (unusedKeys[locale].length > 0) {
+                logger.log(`\n🔍 unused keys in the ${locale} translation file:`);
+                unusedKeys[locale].forEach(key => logger.log(`  - ${key}`));
+            }
+            else {
+                logger.success(`${locale} translation file has no unused keys`);
+            }
+            if (shouldRemove && removedKeys[locale].length > 0) {
+                logger.log(`\n🗑️ deleted keys from the ${locale} translation file:`);
+                removedKeys[locale].forEach(key => logger.log(`  - ${key}`));
+            }
+        });
+        logger.log('\n=== report end ===\n');
+        logger.log("⚠️⚠️⚠️script depends on regular matching, for multiple translation namespaces in a single file, use naming to distinguish: t1 | t2 | t3 | ... ⚠️⚠️⚠️");
+        // save log file
+        logger.saveToFile(logFileName, cwd);
+        // if there are any unused keys or namespaces, return non-zero status code
+        return (Object.values(unusedKeys).some(keys => keys.length > 0) ||
+            Object.values(unusedNamespaces).some(namespaces => namespaces.length > 0)) ? 1 : 0;
+    }
+    catch (error) {
+        logger.error(`error cleaning translations: ${error}`);
+        return 1;
+    }
+}
+
+export { cleanTranslations };

package/dist/commands/create-diaomao-app.d.ts

@@ -0,0 +1,2 @@
+export declare function createDiaomaoApp(targetDir: string): Promise<void>;
+//# sourceMappingURL=create-diaomao-app.d.ts.map

package/dist/commands/create-diaomao-app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-diaomao-app.d.ts","sourceRoot":"","sources":["../../src/commands/create-diaomao-app.ts"],"names":[],"mappings":"AAKA,wBAAsB,gBAAgB,CAAC,SAAS,EAAE,MAAM,iBA6JvD"}