@windrun-huaiin/dev-scripts 6.8.2 → 6.9.0

package/dist/index.mjs

@@ -1,3 +1,4 @@
-export { checkTranslations, cleanTranslations, generateBlogIndex, loadConfig, validateConfig } from './chunk-GVR6HFHM.mjs';
-//# sourceMappingURL=index.mjs.map
-//# sourceMappingURL=index.mjs.map
+export { checkTranslations } from './commands/check-translations.mjs';
+export { cleanTranslations } from './commands/clean-translations.mjs';
+export { generateBlogIndex } from './commands/generate-blog-index.mjs';
+export { loadConfig, validateConfig } from './config/index.mjs';

package/dist/utils/file-scanner.d.ts

@@ -0,0 +1,22 @@
+import { DevScriptsConfig } from '@dev-scripts/config/schema';
+export interface ScanResult {
+    filePath: string;
+    content: string;
+}
+/**
+ * scan matching files
+ */
+export declare function scanFiles(config: DevScriptsConfig, cwd?: string): Promise<ScanResult[]>;
+/**
+ * read JSON file from given path
+ */
+export declare function readJsonFile<T = any>(filePath: string): T | null;
+/**
+ * get translation file path
+ */
+export declare function getTranslationFilePath(locale: string, config: DevScriptsConfig, cwd?: string): string;
+/**
+ * load all translation files
+ */
+export declare function loadTranslations(config: DevScriptsConfig, cwd?: string): Record<string, Record<string, any>>;
+//# sourceMappingURL=file-scanner.d.ts.map

package/dist/utils/file-scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-scanner.d.ts","sourceRoot":"","sources":["../../src/utils/file-scanner.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAE7D,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;GAEG;AACH,wBAAsB,SAAS,CAAC,MAAM,EAAE,gBAAgB,EAAE,GAAG,GAAE,MAA6D,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAsBnJ;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,GAAG,GAAG,EAAE,QAAQ,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI,CAOhE;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,EAAE,GAAG,GAAE,MAA6D,GAAG,MAAM,CAE3J;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,EAAE,GAAG,GAAE,MAA6D,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAgBlK"}

package/dist/utils/file-scanner.js

@@ -0,0 +1,70 @@
+'use strict';
+
+var fg = require('fast-glob');
+var fs = require('fs');
+
+/**
+ * scan matching files
+ */
+async function scanFiles(config, cwd = typeof process !== 'undefined' ? process.cwd() : '.') {
+    const files = await fg(config.scan.include, {
+        ignore: config.scan.exclude || [],
+        cwd,
+        absolute: false
+    });
+    const results = [];
+    for (const file of files) {
+        try {
+            const content = fs.readFileSync(file, 'utf8');
+            results.push({
+                filePath: file,
+                content
+            });
+        }
+        catch (error) {
+            console.warn(`Warning: Failed to read file ${file}: ${error}`);
+        }
+    }
+    return results;
+}
+/**
+ * read JSON file from given path
+ */
+function readJsonFile(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        return null;
+    }
+}
+/**
+ * get translation file path
+ */
+function getTranslationFilePath(locale, config, cwd = typeof process !== 'undefined' ? process.cwd() : '.') {
+    return `${cwd}/${config.i18n.messageRoot}/${locale}.json`;
+}
+/**
+ * load all translation files
+ */
+function loadTranslations(config, cwd = typeof process !== 'undefined' ? process.cwd() : '.') {
+    const translations = {};
+    for (const locale of config.i18n.locales) {
+        const filePath = getTranslationFilePath(locale, config, cwd);
+        const translation = readJsonFile(filePath);
+        if (translation) {
+            translations[locale] = translation;
+        }
+        else {
+            console.warn(`Warning: Failed to load translation file for locale: ${locale}`);
+            translations[locale] = {};
+        }
+    }
+    return translations;
+}
+
+exports.getTranslationFilePath = getTranslationFilePath;
+exports.loadTranslations = loadTranslations;
+exports.readJsonFile = readJsonFile;
+exports.scanFiles = scanFiles;

package/dist/utils/file-scanner.mjs

@@ -0,0 +1,65 @@
+import fg from 'fast-glob';
+import { readFileSync } from 'fs';
+
+/**
+ * scan matching files
+ */
+async function scanFiles(config, cwd = typeof process !== 'undefined' ? process.cwd() : '.') {
+    const files = await fg(config.scan.include, {
+        ignore: config.scan.exclude || [],
+        cwd,
+        absolute: false
+    });
+    const results = [];
+    for (const file of files) {
+        try {
+            const content = readFileSync(file, 'utf8');
+            results.push({
+                filePath: file,
+                content
+            });
+        }
+        catch (error) {
+            console.warn(`Warning: Failed to read file ${file}: ${error}`);
+        }
+    }
+    return results;
+}
+/**
+ * read JSON file from given path
+ */
+function readJsonFile(filePath) {
+    try {
+        const content = readFileSync(filePath, 'utf8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        return null;
+    }
+}
+/**
+ * get translation file path
+ */
+function getTranslationFilePath(locale, config, cwd = typeof process !== 'undefined' ? process.cwd() : '.') {
+    return `${cwd}/${config.i18n.messageRoot}/${locale}.json`;
+}
+/**
+ * load all translation files
+ */
+function loadTranslations(config, cwd = typeof process !== 'undefined' ? process.cwd() : '.') {
+    const translations = {};
+    for (const locale of config.i18n.locales) {
+        const filePath = getTranslationFilePath(locale, config, cwd);
+        const translation = readJsonFile(filePath);
+        if (translation) {
+            translations[locale] = translation;
+        }
+        else {
+            console.warn(`Warning: Failed to load translation file for locale: ${locale}`);
+            translations[locale] = {};
+        }
+    }
+    return translations;
+}
+
+export { getTranslationFilePath, loadTranslations, readJsonFile, scanFiles };

package/dist/utils/logger.d.ts

@@ -0,0 +1,24 @@
+import { DevScriptsConfig } from '@dev-scripts/config/schema';
+export declare class Logger {
+    private messages;
+    private config;
+    constructor(config: DevScriptsConfig);
+    log(message: string): void;
+    error(message: string): void;
+    warn(message: string): void;
+    info(message: string): void;
+    success(message: string): void;
+    /**
+     * save log to file
+     */
+    saveToFile(filename: string, cwd?: string): void;
+    /**
+     * clear log messages
+     */
+    clear(): void;
+    /**
+     * get all log messages
+     */
+    getMessages(): string[];
+}
+//# sourceMappingURL=logger.d.ts.map

package/dist/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAE7D,qBAAa,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAe;IAC/B,OAAO,CAAC,MAAM,CAAkB;gBAEpB,MAAM,EAAE,gBAAgB;IAIpC,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAO1B,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAK5B,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAK3B,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAK3B,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAK9B;;OAEG;IACH,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,GAAE,MAA6D,GAAG,IAAI;IAetG;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,WAAW,IAAI,MAAM,EAAE;CAGxB"}

package/dist/utils/logger.js

@@ -0,0 +1,63 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+
+class Logger {
+    constructor(config) {
+        this.messages = [];
+        this.config = config;
+    }
+    log(message) {
+        if (this.config.output.verbose) {
+            console.log(message);
+        }
+        this.messages.push(message);
+    }
+    error(message) {
+        console.error(message);
+        this.messages.push('[ERROR] ' + message);
+    }
+    warn(message) {
+        console.warn(message);
+        this.messages.push('[WARN] ' + message);
+    }
+    info(message) {
+        console.info(message);
+        this.messages.push('[INFO] ' + message);
+    }
+    success(message) {
+        console.log(`✅ ${message}`);
+        this.messages.push(`[SUCCESS] ${message}`);
+    }
+    /**
+     * save log to file
+     */
+    saveToFile(filename, cwd = typeof process !== 'undefined' ? process.cwd() : '.') {
+        try {
+            const logFilePath = path.join(cwd, this.config.output.logDir, filename);
+            const logDir = path.dirname(logFilePath);
+            // create log directory if it doesn't exist
+            fs.mkdirSync(logDir, { recursive: true });
+            fs.writeFileSync(logFilePath, this.messages.join('\n'), 'utf8');
+            console.log(`log saved to ${logFilePath}`);
+        }
+        catch (error) {
+            console.error(`failed to save log file: ${error}`);
+        }
+    }
+    /**
+     * clear log messages
+     */
+    clear() {
+        this.messages = [];
+    }
+    /**
+     * get all log messages
+     */
+    getMessages() {
+        return [...this.messages];
+    }
+}
+
+exports.Logger = Logger;

package/dist/utils/logger.mjs

@@ -0,0 +1,61 @@
+import { mkdirSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+
+class Logger {
+    constructor(config) {
+        this.messages = [];
+        this.config = config;
+    }
+    log(message) {
+        if (this.config.output.verbose) {
+            console.log(message);
+        }
+        this.messages.push(message);
+    }
+    error(message) {
+        console.error(message);
+        this.messages.push('[ERROR] ' + message);
+    }
+    warn(message) {
+        console.warn(message);
+        this.messages.push('[WARN] ' + message);
+    }
+    info(message) {
+        console.info(message);
+        this.messages.push('[INFO] ' + message);
+    }
+    success(message) {
+        console.log(`✅ ${message}`);
+        this.messages.push(`[SUCCESS] ${message}`);
+    }
+    /**
+     * save log to file
+     */
+    saveToFile(filename, cwd = typeof process !== 'undefined' ? process.cwd() : '.') {
+        try {
+            const logFilePath = join(cwd, this.config.output.logDir, filename);
+            const logDir = dirname(logFilePath);
+            // create log directory if it doesn't exist
+            mkdirSync(logDir, { recursive: true });
+            writeFileSync(logFilePath, this.messages.join('\n'), 'utf8');
+            console.log(`log saved to ${logFilePath}`);
+        }
+        catch (error) {
+            console.error(`failed to save log file: ${error}`);
+        }
+    }
+    /**
+     * clear log messages
+     */
+    clear() {
+        this.messages = [];
+    }
+    /**
+     * get all log messages
+     */
+    getMessages() {
+        return [...this.messages];
+    }
+}
+
+export { Logger };

package/dist/utils/translation-parser.d.ts

@@ -0,0 +1,29 @@
+export interface TranslationInfo {
+    namespaces: Map<string, string>;
+    keys: string[];
+}
+/**
+ * extract translation keys and namespaces from file content
+ */
+export declare function extractTranslationsInfo(content: string, filePath: string): TranslationInfo;
+/**
+ * get all keys from an object (including nested keys)
+ */
+export declare function getAllKeys(obj: Record<string, any>, prefix?: string): string[];
+/**
+ * check if the key exists in the translation file
+ */
+export declare function checkKeyExists(key: string, translations: Record<string, any>): boolean;
+/**
+ * check if the namespace exists in the translation file
+ */
+export declare function checkNamespaceExists(namespace: string, translations: Record<string, any>): boolean;
+/**
+ * remove the specified key from the translation object
+ */
+export declare function removeKeyFromTranslations(key: string, translations: Record<string, any>): boolean;
+/**
+ * clean empty objects (recursively)
+ */
+export declare function cleanEmptyObjects(obj: Record<string, any>): Record<string, any>;
+//# sourceMappingURL=translation-parser.d.ts.map

package/dist/utils/translation-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translation-parser.d.ts","sourceRoot":"","sources":["../../src/utils/translation-parser.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,IAAI,EAAE,MAAM,EAAE,CAAA;CACf;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,eAAe,CA8I1F;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAE,MAAW,GAAG,MAAM,EAAE,CAalF;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,CAYtF;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,CAElG;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,CAuBjG;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAa/E"}

package/dist/utils/translation-parser.js

@@ -0,0 +1,225 @@
+'use strict';
+
+/**
+ * extract translation keys and namespaces from file content
+ */
+function extractTranslationsInfo(content, filePath) {
+    const result = {
+        namespaces: new Map(),
+        keys: []
+    };
+    // match getTranslations({ locale, namespace: 'namespace' }) or getTranslations('namespace')
+    const getTranslationsPattern = /getTranslations\(\s*(?:{[^}]*namespace:\s*['"]([^'"]+)['"][^}]*}|['"]([^'"]+)['"])\s*\)/g;
+    let match;
+    while ((match = getTranslationsPattern.exec(content)) !== null) {
+        const namespace = match[1] || match[2];
+        if (namespace) {
+            // try to find assignment statement, like const t = await getTranslations(...)
+            // find the nearest const declaration
+            const linesBefore = content.substring(0, match.index).split('\n');
+            for (let i = linesBefore.length - 1; i >= Math.max(0, linesBefore.length - 5); i--) {
+                const line = linesBefore[i];
+                const constMatch = /const\s+(\w+)\s*=/.exec(line);
+                if (constMatch && !line.includes('useTranslations') && !line.includes('getTranslations')) {
+                    result.namespaces.set(constMatch[1], namespace);
+                    break;
+                }
+            }
+        }
+    }
+    // match useTranslations('namespace')
+    const useTranslationsPattern = /useTranslations\(\s*['"]([^'"]+)['"]\s*\)/g;
+    while ((match = useTranslationsPattern.exec(content)) !== null) {
+        const namespace = match[1];
+        // try to find assignment statement, like const t = useTranslations(...)
+        // find the line containing useTranslations
+        const currentLine = content.substring(0, match.index).split('\n').pop() || '';
+        const constMatch = /const\s+(\w+)\s*=/.exec(currentLine);
+        if (constMatch) {
+            result.namespaces.set(constMatch[1], namespace);
+        }
+    }
+    // match t('key') or t("key"), and check if t is associated with known namespaces
+    // modify the matching pattern of t function call
+    const tPatterns = [
+        // normal string key: t('key') or t("key")
+        /(\w+)\(\s*['"]([^'"]+)['"]\s*\)/g,
+        // template string key: t(`tags.${id}`) or t(`section.${key}`)
+        /(\w+)\(\s*`([^`]+)`\s*\)/g,
+        // variable key: t(item.key) or t(item.id)
+        /(\w+)\(\s*(\w+)\.(\w+)\s*\)/g
+    ];
+    for (const pattern of tPatterns) {
+        let match;
+        while ((match = pattern.exec(content)) !== null) {
+            const funcName = match[1];
+            // if the function name is associated with known namespaces
+            if (result.namespaces.has(funcName)) {
+                const namespace = result.namespaces.get(funcName);
+                if (!namespace)
+                    continue;
+                if (pattern.source.includes('`')) {
+                    // handle template string
+                    const templateStr = match[2];
+                    // extract static part (the part before the variable)
+                    const staticPart = templateStr.split(/\${(?:id|key)}/)[0].trim();
+                    if (staticPart && !staticPart.includes('/')) {
+                        // for tags.${id}这样的形式，记录整个 tags 命名空间
+                        const segments = staticPart.split('.');
+                        if (segments.length > 0) {
+                            // record the base path
+                            result.keys.push(`${namespace}.${segments[0]}`);
+                            // if it is multi-level, also record the full path
+                            if (segments.length > 1) {
+                                result.keys.push(`${namespace}.${segments.join('.')}`);
+                            }
+                            // special handling for tags namespace
+                            if (segments[0] === 'tags') {
+                                // add all known tag keys
+                                ['productUpdates', 'tutorials', 'makeMoney', 'roadOverSea', 'insights'].forEach(tag => {
+                                    result.keys.push(`${namespace}.tags.${tag}`);
+                                });
+                            }
+                        }
+                    }
+                }
+                else if (pattern.source.includes('\\w+\\.\\w+')) {
+                    // handle variable key t(item.key)
+                    const varName = match[2];
+                    match[3];
+                    // find the possible value of the variable in the file content
+                    const varPattern = new RegExp(`${varName}\\s*=\\s*{[^}]*key:\\s*['"]([^'"]+)['"]`);
+                    const varMatch = content.match(varPattern);
+                    if (varMatch) {
+                        // if the variable definition is found, add the actual key
+                        result.keys.push(`${namespace}.${varMatch[1]}`);
+                    }
+                    else {
+                        // if the specific definition is not found, try to infer from the context
+                        // check if it is used in an array or object of MenuItem type
+                        if (content.includes('MenuItem[]') || content.includes('MenuItem}')) {
+                            // add all possible menu keys
+                            ['journey'].forEach(menuKey => {
+                                result.keys.push(`${namespace}.${menuKey}`);
+                            });
+                        }
+                    }
+                }
+                else {
+                    // handle normal string key
+                    const key = match[2];
+                    if (!key.includes('/') && key !== '') {
+                        result.keys.push(`${namespace}.${key}`);
+                    }
+                }
+            }
+        }
+    }
+    // match <FormattedMessage id="key" />
+    const formattedMessagePattern = /<FormattedMessage[^>]*id=['"]([^'"]+)['"]/g;
+    while ((match = formattedMessagePattern.exec(content)) !== null) {
+        const key = match[1];
+        if (!key.includes('/') && key !== '') {
+            // for FormattedMessage, we need to guess the namespace
+            // usually we can find useTranslations call in the same file
+            if (result.namespaces.size > 0) {
+                const namespace = Array.from(result.namespaces.values())[0];
+                result.keys.push(`${namespace}.${key}`);
+            }
+            else {
+                // if the namespace is not found, try to infer from the file path
+                const pathMatch = filePath.match(/\[locale\]\/(?:\([^)]+\)\/)?([^/]+)/);
+                if (pathMatch && pathMatch[1]) {
+                    const possibleNamespace = pathMatch[1];
+                    result.keys.push(`${possibleNamespace}.${key}`);
+                }
+            }
+        }
+    }
+    return result;
+}
+/**
+ * get all keys from an object (including nested keys)
+ */
+function getAllKeys(obj, prefix = '') {
+    let keys = [];
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            const newKey = prefix ? `${prefix}.${key}` : key;
+            if (typeof obj[key] === 'object' && obj[key] !== null) {
+                keys = [...keys, ...getAllKeys(obj[key], newKey)];
+            }
+            else {
+                keys.push(newKey);
+            }
+        }
+    }
+    return keys;
+}
+/**
+ * check if the key exists in the translation file
+ */
+function checkKeyExists(key, translations) {
+    const parts = key.split('.');
+    let current = translations;
+    for (const part of parts) {
+        if (current[part] === undefined) {
+            return false;
+        }
+        current = current[part];
+    }
+    return true;
+}
+/**
+ * check if the namespace exists in the translation file
+ */
+function checkNamespaceExists(namespace, translations) {
+    return translations[namespace] !== undefined;
+}
+/**
+ * remove the specified key from the translation object
+ */
+function removeKeyFromTranslations(key, translations) {
+    const parts = key.split('.');
+    const lastPart = parts.pop();
+    if (!lastPart)
+        return false;
+    let current = translations;
+    // navigate to the parent object of the last level
+    for (const part of parts) {
+        if (current[part] === undefined || typeof current[part] !== 'object') {
+            return false;
+        }
+        current = current[part];
+    }
+    // delete the key
+    if (current[lastPart] !== undefined) {
+        delete current[lastPart];
+        return true;
+    }
+    return false;
+}
+/**
+ * clean empty objects (recursively)
+ */
+function cleanEmptyObjects(obj) {
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            if (typeof obj[key] === 'object' && obj[key] !== null) {
+                obj[key] = cleanEmptyObjects(obj[key]);
+                // if the object is empty, delete it
+                if (Object.keys(obj[key]).length === 0) {
+                    delete obj[key];
+                }
+            }
+        }
+    }
+    return obj;
+}
+
+exports.checkKeyExists = checkKeyExists;
+exports.checkNamespaceExists = checkNamespaceExists;
+exports.cleanEmptyObjects = cleanEmptyObjects;
+exports.extractTranslationsInfo = extractTranslationsInfo;
+exports.getAllKeys = getAllKeys;
+exports.removeKeyFromTranslations = removeKeyFromTranslations;