xshell 1.2.47 → 1.2.48

package/builder.js

@@ -316,6 +316,9 @@ export class Bundler {
                                     transpileOnly: !this.dts,
                                     compilerOptions: {
                                         module: 'ESNext',
+                                        // 编译 using 和 await using
+                                        // todo: 等 webpack 的 acorn 原生支持解析语法后可删去
+                                        target: 'ES2024',
                                         moduleResolution: 'Bundler',
                                         declaration: this.dts,
                                         noEmit: false,

package/i18n/i18n-scan.js

@@ -2,19 +2,10 @@
 import { program } from 'commander';
 import { path } from "../path.js";
 import { scanner } from "./scanner/index.js";
-import { try_load_dict } from "./utils.js";
-(async function main() {
-    program.name('i18n-scan')
-        .option('-r, --rootdir [rootdir]', '根目录：默认为当前工作目录', path.normalize(process.cwd()))
-        .option('-i, --input [input]', '扫描 pattern：多个 pattern 用分号分割，采用 glob pattern 匹配，如 `src/**/*.{js,jsx,ts,tsx}`', v => v.split(';'))
-        .option('-o, --output [output]', 'i18n 目录：默认为 <rootdir>/i18n/')
-        .option('-c, --config [config]', '自定义配置文件，默认为 <rootdir>/i18n/config.js ，可参考默认配置 xshell/i18n/index.ts 以及 https://github.com/i18next/i18next-scanner', 'i18n/config.js')
-        .parse(process.argv);
-    const { rootdir, config, input, output } = program.opts();
-    scanner(rootdir, {
-        ...await try_load_dict(path.resolve(rootdir, config)),
-        ...input ? { input } : {},
-        ...output ? { output } : {},
-    });
-})();
+program.name('i18n-scan')
+    .option('-r, --rootdir [rootdir]', '根目录：默认为当前工作目录', path.normalize(process.cwd()).fpd)
+    .option('-o, --output [output]', 'i18n 目录：默认为 <rootdir>/i18n/')
+    .parse(process.argv);
+const { rootdir, output } = program.opts();
+await scanner(rootdir, output ? { output } : undefined);
 //# sourceMappingURL=i18n-scan.js.map

package/i18n/index.d.ts

@@ -2,7 +2,7 @@ import { type i18n as I18Next } from 'i18next';
 import type { Trans } from 'react-i18next';
 import { type _Dict, type Item } from './dict.ts';
 export type Language = 'zh' | 'en' | 'ja' | 'ko';
-export declare const LANGUAGES: readonly ["zh", "en", "ja", "ko"];
+export declare const languages: readonly ["zh", "en", "ja", "ko"];
 declare global {
     interface Window {
         language: Language;

package/i18n/index.js

@@ -1,6 +1,6 @@
 import { default as i18next } from 'i18next';
 import { Dict } from "./dict.js";
-export const LANGUAGES = ['zh', 'en', 'ja', 'ko'];
+export const languages = ['zh', 'en', 'ja', 'ko'];
 /**
     提供翻译文本功能，自动解析当前语言
     @see https://github.com/ShenHongFei/xshell/tree/master/i18n

package/i18n/scanner/index.d.ts

@@ -1,8 +1,12 @@
 import '../../prototype.ts';
+/** 扫描源码中的词条，以及收集未翻译的词条，将结果保存到 dict.json 和 untranslateds.json
+    - `process.cwd()` rootdir 要扫描根目录
+    - config 配置信息 */
+export declare function scanner(fpd_root: string, config?: Config): Promise<number>;
 /** 默认 i18next 扫描配置 */
-declare const DEFAULT_CONFIG: {
+declare const default_config: {
     debug: boolean;
-    input: string[];
+    input: any[];
     output: string;
     dict: string[];
     lngs: string[];
@@ -35,7 +39,7 @@ declare const DEFAULT_CONFIG: {
         suffix: string;
     };
 };
-export type Config = Partial<(typeof DEFAULT_CONFIG) & {
+export type Config = Partial<(typeof default_config) & {
     defaultValue?: string;
     resource?: {
         loadPath?: string;
@@ -44,9 +48,4 @@ export type Config = Partial<(typeof DEFAULT_CONFIG) & {
         lineEnding?: '\n';
     };
 }>;
-/** 扫描源码中的词条，以及收集未翻译的词条，将结果保存到 dict.json 和 untranslateds.json
-    - `process.cwd()` rootdir 要扫描根目录
-    - config 配置信息
-*/
-export declare function scanner(rootdir?: string, config?: Config): Promise<number>;
 export {};

package/i18n/scanner/index.js

@@ -1,27 +1,155 @@
-import i18n_scanner from 'i18next-scanner';
-import vfs from 'vinyl-fs';
-import sort from 'gulp-sort';
-import ora from 'ora';
-import cli_truncate from 'cli-truncate';
-import Vinyl from 'vinyl';
-import through2 from 'through2';
-import CliTable from 'cli-table3';
+import { Parser } from 'i18next-scanner';
 import "../../prototype.js";
 import { path } from "../../path.js";
-import { map_stream } from "../../utils.js";
-import { LANGUAGES } from "../index.js";
+import { flist, fread, fwrite } from "../../file.js";
+import { noprint } from "../../process.js";
+import { rethrow } from "../../prototype.js";
+import { languages } from "../index.js";
 import { RWDict } from "../rwdict.js";
 import { try_load_dict } from "../utils.js";
-import { mix_parse_trans_from_string_by_babel } from "./parser.js";
+import { parse_trans_from_string_by_babel } from "./parser.js";
+/** 扫描源码中的词条，以及收集未翻译的词条，将结果保存到 dict.json 和 untranslateds.json
+    - `process.cwd()` rootdir 要扫描根目录
+    - config 配置信息 */
+export async function scanner(fpd_root, config = {}) {
+    const fpd_out = path.resolve(fpd_root, config.output || default_config.output).fpd;
+    config = {
+        ...default_config,
+        ...config,
+        output: fpd_out,
+        resource: {
+            loadPath: '',
+            savePath: `${fpd_out}translation/{{lng}}.js`,
+            jsonIndent: 4,
+            lineEnding: '\n'
+        }
+    };
+    let dict = new RWDict();
+    for (const fp_dict of config.dict)
+        dict.merge(await try_load_dict(`${fpd_out}${fp_dict}`), { print: false, overwrite: true });
+    // 所有语言的扫描统计信息
+    let stats = {};
+    for (const language of languages)
+        stats[language] = {
+            translateds: new Set(),
+            untranslateds: new Set()
+        };
+    function on_scanned(text, { language, key, defaultValue, count, context }) {
+        // console.log(text, { language, key, defaultValue, count, context })
+        text ||= defaultValue;
+        if (!key)
+            key = context ? `${text}_${context}` : text;
+        if (!language) {
+            for (const language of languages)
+                on_scanned(text, { language, key, count, context });
+            return;
+        }
+        // console.log(text, { language, key, defaultValue, count, context })
+        const stat = stats[language];
+        // 获取已有翻译
+        const translation = dict.get(key, language) ||
+            language === 'zh' && text ||
+            '';
+        if (language === 'zh' && !context)
+            return;
+        if (translation)
+            stat.translateds.add(key);
+        else
+            stat.untranslateds.add(key);
+        if (language === 'en' && count !== undefined)
+            on_scanned(text, { language, key: `${key}_plural`, context });
+    }
+    let parser = new Parser(config);
+    let mixed = false;
+    (await Promise.all((await flist(fpd_root, {
+        print: false,
+        deep: true,
+        filter: fp => fp.isdir ?
+            !(fp.startsWith('.') || excludes.includes(fp.fname))
+            :
+                fp.endsWith('.ts') && !fp.endsWith('.d.ts') || fp.endsWith('.tsx')
+    }))
+        .filter(fp => !fp.isdir)
+        .map(async (fp) => [fp, await fread(`${fpd_root}${fp}`, noprint)]))).forEach(([fp, code]) => {
+        // --- 添加代码中扫描到的 t('key') 中的 key 到 parser
+        // parser.parseFuncFromString 使用 esprima 来解析代码，esprima 仍然不支持 optional chaining !!
+        parser.parseFuncFromString(code.replace(/\?\.\[/g, '[').replace(/\?\.\(/g, '(').replace(/\?\./g, '.'), on_scanned);
+        // --- 添加代码中扫描到的 Trans 组件中的 key 到 parser
+        if (fp.endsWith('.tsx') && code.includes('<Trans')) {
+            // parser.parseTransFromString 使用 acorn 解析代码，不支持 TypeScript，添加 parser.parseTransFromStringByBabel
+            if (!mixed) {
+                mixed = true;
+                parser.parseTransFromStringByBabel = parse_trans_from_string_by_babel;
+            }
+            parser.parseTransFromStringByBabel(code, { filepath: fp }, on_scanned, rethrow);
+        }
+    });
+    // --- 打印词条统计表
+    console.log('扫描完成\n' +
+        pad('语言', 0) + pad('未翻译', 1).red + pad('已翻译', 2).green + '\n' +
+        Object.entries(stats)
+            .filter(([lang, stat]) => lang === 'en' || stat.translateds.size)
+            .map(([lang, stat]) => pad(lang, 0) + pad(String(stat.untranslateds.size), 1).red + pad(String(stat.translateds.size), 2).green).join_lines(false));
+    const en_untranslateds = stats.en.untranslateds;
+    const n_en_untranslateds = en_untranslateds.size;
+    if (n_en_untranslateds) {
+        console.log('\n缺少英文翻译的词条:'.yellow);
+        let i = 0;
+        for (const untranslated of en_untranslateds) {
+            if (i >= 10)
+                break;
+            console.log(untranslated);
+            i++;
+        }
+        if (n_en_untranslateds > 10) {
+            console.log('...');
+            console.log(`--- 共 ${en_untranslateds.size} 个未翻译的英文词条 ---`);
+        }
+    }
+    else
+        console.log('\n所有词条都至少含有英文翻译'.green);
+    // --- 生成 untranslateds.json，并自动翻译 (扫描到词条还没有英文翻译)
+    let untranslateds = {};
+    if (n_en_untranslateds) {
+        const _en_untranslateds = [...en_untranslateds];
+        for (let i = 0; i < _en_untranslateds.length; ++i) {
+            const key = _en_untranslateds[i];
+            let item = { ...dict.get(key) };
+            item.en ||= '';
+            item.ja ||= '';
+            item.ko ||= '';
+            untranslateds[key] = item;
+        }
+    }
+    // --- 保存到 dict.json, untranslateds.json
+    const fp_untranslateds = `${fpd_out}untranslateds.json`;
+    const fp_dict_ = `${fpd_out}dict.json`;
+    await Promise.all([
+        fwrite(fp_untranslateds, untranslateds, noprint),
+        fwrite(fp_dict_, dict.to_json(true) + '\n', noprint)
+    ]);
+    console.log((n_en_untranslateds ?
+        `${'请手动补全未翻译的词条: '.yellow}${fp_untranslateds.underline.blue}\n` +
+            '补全 untranslateds.json 后需要重新运行扫描，会根据 untranslateds.json 更新 dict.json\n'.yellow
+        :
+            '') +
+        `${'请检查词典文件: '}${fp_dict_.underline.blue}\n` +
+        '最后词典文件中词条会被打包进 js, 通过 new I18N(<dict.json>) 或 i18n.init(<dict.json>) 加载\n');
+    return n_en_untranslateds;
+}
+function pad(str, index) {
+    return str.pad(widths[index], { position: 'left' });
+}
+const widths = [6, 8, 8];
+const excludes = [
+    'node_modules/',
+    'out/',
+    'dist/',
+];
 /** 默认 i18next 扫描配置 */
-const DEFAULT_CONFIG = {
+const default_config = {
     debug: false,
-    input: [
-        // 'src/**/*.{js,jsx,ts,tsx}',
-        '!i18n/**', // Use ! to filter out files or directories
-        '!node_modules/**',
-        '!**/*.d.ts',
-    ],
+    input: [],
     // 相对于根目录
     output: 'i18n/',
     // 若是相对路径，则以 output 为基准进行解析
@@ -31,7 +159,7 @@ const DEFAULT_CONFIG = {
     defaultLng: 'zh',
     defaultNs: 'translation',
     func: {
-        list: ['i18next.t', 'i18n.t', 'i18n.__', 't', '__'],
+        list: ['t'],
         extensions: [], // 避免在 transform 中执行原生的 parseFuncFromString
     },
     trans: {
@@ -93,245 +221,4 @@ const DEFAULT_CONFIG = {
         suffix: '}}' // suffix for interpolation
     }
 };
-const VALID_EXTENTIONS = new Set(['.js', '.jsx', '.ts', '.tsx']);
-/** 扫描源码中的词条，以及收集未翻译的词条，将结果保存到 dict.json 和 untranslateds.json
-    - `process.cwd()` rootdir 要扫描根目录
-    - config 配置信息
-*/
-export async function scanner(rootdir = path.normalize(process.cwd()), config = {}) {
-    const output = path.resolve(rootdir, config.output || DEFAULT_CONFIG.output);
-    if (!config.input.length)
-        throw new Error('运行 i18n-scan 请指定 --input');
-    const input = [...config.input, ...DEFAULT_CONFIG.input];
-    config = {
-        ...DEFAULT_CONFIG,
-        ...config,
-        input,
-        output,
-        resource: {
-            loadPath: '',
-            savePath: path.resolve(output, 'translation/{{lng}}.js'),
-            jsonIndent: 4,
-            lineEnding: '\n'
-        }
-    };
-    let dict = new RWDict();
-    for (const fp_dict of config.dict)
-        dict.merge(await try_load_dict(path.resolve(output, fp_dict)), { print: false, overwrite: true });
-    let c_files = 0;
-    let c_scanneds = 0;
-    let error_handlers = [];
-    // 所有语言的扫描统计信息
-    let stats = {};
-    for (const language of LANGUAGES)
-        stats[language] = {
-            translateds: new Set(),
-            untranslateds: new Set()
-        };
-    let spinner = ora({ interval: 66 }).start('Scanning...');
-    function on_scanned(text, { language, key, defaultValue, count, context }) {
-        // console.log(text, { language, key, defaultValue, count, context })
-        text = text || defaultValue;
-        if (!key)
-            key = context ? `${text}_${context}` : text;
-        if (!language) {
-            for (const language of LANGUAGES)
-                on_scanned(text, { language, key, count, context });
-            return;
-        }
-        // console.log(text, { language, key, defaultValue, count, context })
-        // debugger
-        const stat = stats[language];
-        // 获取已有翻译
-        const translation = dict.get(key, language) ||
-            language === 'zh' && text ||
-            '';
-        if (language === 'zh' && !context)
-            return;
-        if (translation)
-            stat.translateds.add(key);
-        else
-            stat.untranslateds.add(key);
-        if (language === 'en' && count !== undefined)
-            on_scanned(text, { language, key: `${key}_plural`, context });
-    }
-    function new_vinyl_file(_path, data) {
-        return new Vinyl({
-            cwd: rootdir,
-            base: rootdir,
-            path: path.resolve(config.output, _path),
-            contents: Buffer.from(typeof data === 'string' ? data : JSON.stringify(data, null, 4))
-        });
-    }
-    return new Promise((resolve, reject) => {
-        // ------------ scan by file
-        vfs
-            .src(config.input, { cwd: rootdir, sync: false })
-            // 每个文件扫描前，统计文件数量
-            .pipe(map_stream((file, cb) => {
-            // 支持 `// @i18n-noscan` 忽略扫描
-            if (/\/\/\s*@i18n-noscan\s/.test(file.contents.toString()))
-                return cb();
-            c_files++;
-            cb(null, file);
-        }))
-            // 对文件进行排序，保证词条有一定的顺序
-            .pipe(sort())
-            // 分析代码提取词条
-            .pipe(i18n_scanner.createStream(config, function transform(file, encoding, callback) {
-            const { parser } = this;
-            const ext = path.extname(file.path);
-            // 只扫描源码文件
-            if (!VALID_EXTENTIONS.has(ext)) {
-                callback();
-                return;
-            }
-            c_scanneds++;
-            const percent = Math.round(100 * c_scanneds / c_files);
-            const text = `Scanning (${percent}%): ${file.path.blue}`;
-            spinner.text = cli_truncate(text, process.stdout.columns - 5, { position: 'middle', });
-            let code = file.contents.toString();
-            // --- 添加代码中扫描到的 i18n.t('key') 中的 key 到 parser
-            // parser.parseFuncFromString 使用 esprima 来解析代码，esprima 仍然不支持 optional chaining !!
-            parser.parseFuncFromString(code.replace(/\?\.\[/g, '[').replace(/\?\.\(/g, '(').replace(/\?\./g, '.'), on_scanned);
-            // --- 添加代码中扫描到的 Trans 组件中的 key 到 parser
-            if (ext === '.jsx' || ext === '.tsx') {
-                // parser.parseTransFromString 使用 acorn 解析代码，不支持 TypeScript，添加 parser.parseTransFromStringByBabel
-                mix_parse_trans_from_string_by_babel(parser);
-                parser.parseTransFromStringByBabel(code, { filepath: file.path }, on_scanned, (error) => {
-                    error_handlers.push(error);
-                });
-            }
-            setTimeout(callback, 0);
-        }))
-            // 创建词条文件
-            .pipe(through2.obj(
-        /** i18n-scanner 会把扫描结果以每个语言一个文件的形式提供，这里解析扫描结果
-        * file: 翻译 resource 文件，其中 file.contents 包含翻译的扫描结果
-        */
-        function write(file, encoding, cb) { cb(); }, 
-        /** 生成 stats.json, unmarkeds.md； 打印 untranslated / unmarkeds */
-        function flush(cb) {
-            // ------------ stats.json
-            // this.push(new_vinyl_file('stats.json', 
-            //     Object.fromEntries(
-            //         Object.entries(stats).map( ([l, { translateds, untranslateds }]) => 
-            //             [l, { translateds: Array.from(translateds), untranslateds: Array.from(untranslateds) }])
-            //     )
-            // ))
-            // ------------ 打印 cli 统计表
-            const table = new CliTable({
-                head: [
-                    '语言',
-                    '未翻译'.red,
-                    '已翻译'.green,
-                ],
-                colAligns: ['right', 'right', 'right', 'right'],
-                style: { head: [] },
-                chars: {
-                    top: '',
-                    'top-mid': '',
-                    'top-left': '',
-                    'top-right': '',
-                    bottom: '',
-                    'bottom-mid': '',
-                    'bottom-left': '',
-                    'bottom-right': '',
-                    left: '',
-                    'left-mid': '',
-                    mid: '',
-                    'mid-mid': '',
-                    right: '',
-                    'right-mid': '',
-                    middle: ' ',
-                },
-            });
-            Object.entries(stats).forEach(([lang, stat]) => {
-                table.push([
-                    lang,
-                    String(stat.untranslateds.size).red,
-                    String(stat.translateds.size).green
-                ]);
-            });
-            spinner.stop();
-            console.log(`Scanned ${c_files} files. Occured ${error_handlers.length} errors.`);
-            console.log(table.toString());
-            // ------------ 生成 unmarkeds.md 统计
-            /*
-            const fp_unmarked = path.resolve(config.output, 'unmarkeds.md')
-            
-            if (fs.existsSync(fp_unmarked))
-                rimraf.sync(fp_unmarked)
-            
-            if (unmarkeds.length) {
-                console.log(colors.yellow(`\n⚠️  发现未标记的中文字符 ${unmarkeds.length} 处：\n`))
-                unmarkeds.forEach(({ value, filepath, loc: { start } }, index) => {
-                    if (index >= 5) return
-                    console.log( `  ${colors.white(`'${value}'`)}\t${colors.blue.underline(`${path.relative(rootdir, filepath)}:${start.line}:${start.column + 1}`)}` )
-                })
-            }
-            
-            this.push( new_vinyl_file( fp_unmarked,
-                unmarkeds.map( ({ value, filepath, loc }) =>
-                    '- [' + value.trim() + '](' + path.relative( config.output, path.resolve(rootdir, filepath || '') ) + '#L' + loc.start.line + ')'
-                ).join('\n') + '\n'
-            ))
-            
-            
-            if (unmarkeds.length > 5) {
-                console.log('  ...')
-                console.log(colors.yellow(`\n  完整未标记词条请查看 ${colors.blue.underline(path.relative(rootdir, fp_unmarked))}`))
-            }
-            */
-            const en_untranslateds = stats.en.untranslateds;
-            if (en_untranslateds.size) {
-                console.log('\n缺少英文翻译的词条:'.yellow);
-                let i = 0;
-                for (const untranslated of en_untranslateds) {
-                    if (i >= 10)
-                        break;
-                    console.log(untranslated);
-                    i++;
-                }
-                if (en_untranslateds.size > 10) {
-                    console.log('...');
-                    console.log(`--- 共 ${en_untranslateds.size} 个未翻译的英文词条 ---`);
-                }
-            }
-            else
-                console.log('\n所有词条都至少含有英文翻译'.green);
-            // ------------ 生成 untranslateds.json (扫描到词条还没有英文翻译)
-            const fp_untranslateds = path.resolve(config.output, 'untranslateds.json');
-            let untranslateds = {};
-            for (const key of stats.en.untranslateds) {
-                let item = { ...dict.get(key) };
-                item.en ||= '';
-                item.ja ||= '';
-                item.ko ||= '';
-                untranslateds[key] = item;
-            }
-            this.push(new_vinyl_file(fp_untranslateds, untranslateds));
-            // ------------ 写入 dict.json
-            const fp_dict_new = path.resolve(output, 'dict.json');
-            this.push(new_vinyl_file(fp_dict_new, dict.to_json(true) + '\n'));
-            console.log(`\n\n${'请手动补全未翻译的词条: '.yellow}${fp_untranslateds.underline.blue}\n` +
-                `${'请检查新生成的词典文件: '.yellow}${fp_dict_new.underline.blue}\n` +
-                '\n' +
-                '补全 untranslateds.json 后需要重新运行扫描，会根据 untranslateds.json 更新 dict.json\n'.yellow +
-                '最后 dict.json 所包含的词条会被打包进 js, 通过 new I18N(<dict.json>) 或 i18n.init(<dict.json>) 加载\n\n'.yellow +
-                `${'详细文档请查看: '.yellow}${'https://github.com/ShenHongFei/xshell/tree/master/i18n'.blue.underline}`);
-            cb();
-        }))
-            // 写入词条文件
-            .pipe(vfs.dest(rootdir))
-            .on('end', () => {
-            if (error_handlers.length) {
-                for (const error_handler of error_handlers)
-                    error_handler();
-                console.log(`以上错误可能是由不规范的词条标记导致，标记规范可见：\n${'https://www.i18next.com/translation-function/essentials'.blue.underline}`);
-            }
-            resolve(stats.en.untranslateds.size);
-        });
-    });
-}
 //# sourceMappingURL=index.js.map

package/i18n/scanner/parser.d.ts

@@ -1,3 +1,3 @@
 import '../../prototype.ts';
-/** file:///D:/0/i18next-scanner/src/parser.js */
-export declare function mix_parse_trans_from_string_by_babel(parser: any): void;
+/** i18next-scanner/src/parser.js */
+export declare function parse_trans_from_string_by_babel(this: any, code: string, options?: {}, custom_handler?: any, on_error?: (callback: Function) => void): any;

package/i18n/scanner/parser.js

@@ -5,109 +5,107 @@ import { parse } from '@babel/parser';
 import t from '@babel/types';
 import "../../prototype.js";
 // import { Checker } from './checker'
-/** file:///D:/0/i18next-scanner/src/parser.js */
-export function mix_parse_trans_from_string_by_babel(parser) {
-    parser.parseTransFromStringByBabel = function parse_trans_from_string_by_babel(code, options = {}, custom_handler = null, on_error = () => { }) {
-        if (typeof options === 'function') {
-            custom_handler = options;
-            options = {};
-        }
-        const { transformOptions = {}, // object
-        component = this.options.trans.component, // string
-        i18nKey = this.options.trans.i18nKey, // string
-        defaultsKey = this.options.trans.defaultsKey, // string
-        fallbackKey = this.options.trans.fallbackKey, // boolean|function
-        babylon: babylon_options = this.options.trans.babylon, // object
-        filepath, } = options;
-        const parseJSXElement = ({ node }) => {
-            if (!node)
-                return;
-            if (node.openingElement.name.name !== component)
-                return;
-            const getLiteralValue = literal => {
-                if (t.isTemplateLiteral(literal))
-                    return literal.quasis.map(element => element.value.cooked).join('');
-                return literal.value;
-            };
-            const attr = castArray(node.openingElement.attributes).reduce((acc, attribute) => {
-                if (!t.isJSXAttribute(attribute) ||
-                    !t.isJSXIdentifier(attribute.name))
-                    return acc;
-                const { name } = attribute.name;
-                const value = attribute.value;
-                if (t.isLiteral(value))
-                    acc[name] = getLiteralValue(value);
-                else if (t.isJSXExpressionContainer(value)) {
-                    const expression = value.expression;
-                    if (t.isIdentifier(expression))
-                        acc[name] = expression.name;
-                    else if (t.isLiteral(expression))
-                        acc[name] = getLiteralValue(expression);
-                    else if (t.isObjectExpression(expression)) {
-                        const properties = castArray(expression.properties);
-                        acc[name] = properties.reduce((obj, property) => {
-                            if (!t.isObjectProperty(property))
-                                return obj;
-                            if (t.isLiteral(property.value))
-                                obj[property.key.name] = getLiteralValue(property.value);
-                            else // Unable to get value of the property
-                                obj[property.key.name] = '';
+/** i18next-scanner/src/parser.js */
+export function parse_trans_from_string_by_babel(code, options = {}, custom_handler = null, on_error = () => { }) {
+    if (typeof options === 'function') {
+        custom_handler = options;
+        options = {};
+    }
+    const { transformOptions = {}, // object
+    component = this.options.trans.component, // string
+    i18nKey = this.options.trans.i18nKey, // string
+    defaultsKey = this.options.trans.defaultsKey, // string
+    fallbackKey = this.options.trans.fallbackKey, // boolean|function
+    babylon: babylon_options = this.options.trans.babylon, // object
+    filepath, } = options;
+    const parseJSXElement = ({ node }) => {
+        if (!node)
+            return;
+        if (node.openingElement.name.name !== component)
+            return;
+        const getLiteralValue = literal => {
+            if (t.isTemplateLiteral(literal))
+                return literal.quasis.map(element => element.value.cooked).join('');
+            return literal.value;
+        };
+        const attr = cast_array(node.openingElement.attributes).reduce((acc, attribute) => {
+            if (!t.isJSXAttribute(attribute) ||
+                !t.isJSXIdentifier(attribute.name))
+                return acc;
+            const { name } = attribute.name;
+            const value = attribute.value;
+            if (t.isLiteral(value))
+                acc[name] = getLiteralValue(value);
+            else if (t.isJSXExpressionContainer(value)) {
+                const expression = value.expression;
+                if (t.isIdentifier(expression))
+                    acc[name] = expression.name;
+                else if (t.isLiteral(expression))
+                    acc[name] = getLiteralValue(expression);
+                else if (t.isObjectExpression(expression)) {
+                    const properties = cast_array(expression.properties);
+                    acc[name] = properties.reduce((obj, property) => {
+                        if (!t.isObjectProperty(property))
                             return obj;
-                        }, {});
-                        /** 防止 count 被忽略，如
-                            ```jsx
-                            <Trans count={arr.length}>
-                             一二三{{ count: arr.length }}
-                            </Trans>
-                            ``` */
-                    }
-                    else if (name === 'count')
-                        acc[name] = 0;
+                        if (t.isLiteral(property.value))
+                            obj[property.key.name] = getLiteralValue(property.value);
+                        else // Unable to get value of the property
+                            obj[property.key.name] = '';
+                        return obj;
+                    }, {});
+                    /** 防止 count 被忽略，如
+                        ```jsx
+                        <Trans count={arr.length}>
+                         一二三{{ count: arr.length }}
+                        </Trans>
+                        ``` */
                 }
-                return acc;
-            }, {});
-            const transKey = attr[i18nKey].trim();
-            const defaultsString = attr[defaultsKey] || '';
-            if (typeof defaultsString !== 'string')
-                this.log(`defaults value must be a static string, saw ${defaultsString.yellow}`);
-            // https://www.i18next.com/translation-function/essentials#overview-options
-            const tOptions = attr.tOptions;
-            const options = {
-                ...tOptions,
-                defaultValue: defaultsString || nodes_to_string(node.children, filepath, on_error),
-                fallbackKey,
-            };
-            if (Object.prototype.hasOwnProperty.call(attr, 'count'))
-                options.count = Number(attr.count) || 0;
-            if (Object.prototype.hasOwnProperty.call(attr, 'ns')) {
-                if (typeof options.ns !== 'string')
-                    this.log(`The ns attribute must be a string, saw ${attr.ns?.yellow}`);
-                options.ns = attr.ns;
-            }
-            if (custom_handler) {
-                custom_handler(transKey, options);
-                return;
+                else if (name === 'count')
+                    acc[name] = 0;
             }
-            this.set(transKey, options);
+            return acc;
+        }, {});
+        const transKey = attr[i18nKey]?.trim();
+        const defaultsString = attr[defaultsKey] || '';
+        if (typeof defaultsString !== 'string')
+            this.log(`defaults value must be a static string, saw ${defaultsString.yellow}`);
+        // https://www.i18next.com/translation-function/essentials#overview-options
+        const tOptions = attr.tOptions;
+        const options = {
+            ...tOptions,
+            defaultValue: defaultsString || nodes_to_string(node.children, filepath, on_error),
+            fallbackKey,
         };
-        try {
-            const ast = parse(code, { ...babylon_options });
-            traverse(ast, { JSXElement: parseJSXElement, });
-            // traverse(ast, Checker({ filepath }))
+        if (Object.prototype.hasOwnProperty.call(attr, 'count'))
+            options.count = Number(attr.count) || 0;
+        if (Object.prototype.hasOwnProperty.call(attr, 'ns')) {
+            if (typeof options.ns !== 'string')
+                this.log(`The ns attribute must be a string, saw ${attr.ns?.yellow}`);
+            options.ns = attr.ns;
         }
-        catch (err) {
-            on_error(() => {
-                console.error('');
-                const { line, column } = (err && err.loc) || { line: 1, column: 1 };
-                console.error([filepath, line, column].join(':').yellow);
-                console.error(`Unable to parse ${component?.blue} component.\n`.red);
-                if (!filepath)
-                    console.error(String(code).red);
-                console.error(('    ' + err.message).red);
-            });
+        if (custom_handler) {
+            custom_handler(transKey, options);
+            return;
         }
-        return this;
+        this.set(transKey, options);
     };
+    try {
+        const ast = parse(code, { ...babylon_options });
+        traverse(ast, { JSXElement: parseJSXElement, });
+        // traverse(ast, Checker({ filepath }))
+    }
+    catch (err) {
+        on_error(() => {
+            console.error('');
+            const { line, column } = (err && err.loc) || { line: 1, column: 1 };
+            console.error([filepath, line, column].join(':').yellow);
+            console.error(`Unable to parse ${component?.blue} component.\n`.red);
+            if (!filepath)
+                console.error(String(code).red);
+            console.error(('    ' + err.message).red);
+        });
+    }
+    return this;
 }
 function nodes_to_string(nodes, filepath, onError) {
     let memo = '';
@@ -145,7 +143,7 @@ function nodes_to_string(nodes, filepath, onError) {
     });
     return memo;
 }
-function castArray(value) {
+function cast_array(value) {
     return Array.isArray(value) ? value : [value];
 }
 //# sourceMappingURL=parser.js.map

package/net.d.ts

@@ -297,5 +297,5 @@ export declare class RemoteClient {
     [inspect.custom](): {
         remote: string;
         websocket: string;
-    } & Omit<this, typeof import("util").inspect.custom | "websocket" | "remote" | "call" | "send">;
+    } & Omit<this, "websocket" | typeof import("util").inspect.custom | "call" | "remote" | "send">;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "xshell",
-    "version": "1.2.47",
+    "version": "1.2.48",
     "type": "module",
     "main": "./index.js",
     "bin": {
@@ -57,20 +57,17 @@
         "@svgr/webpack": "^8.1.0",
         "@types/sass-loader": "^8.0.9",
         "@types/ws": "^8.18.1",
-        "@typescript-eslint/eslint-plugin": "^8.33.1",
-        "@typescript-eslint/parser": "^8.33.1",
-        "@typescript-eslint/utils": "^8.33.1",
+        "@typescript-eslint/eslint-plugin": "^8.34.0",
+        "@typescript-eslint/parser": "^8.34.0",
+        "@typescript-eslint/utils": "^8.34.0",
         "archiver": "^7.0.1",
         "chalk": "^5.4.1",
-        "cli-table3": "^0.6.5",
-        "cli-truncate": "^4.0.0",
         "commander": "^14.0.0",
         "css-loader": "^7.1.2",
         "emoji-regex": "^10.4.0",
         "eslint": "^9.28.0",
         "eslint-plugin-import": "^2.31.0",
         "eslint-plugin-react": "^7.37.5",
-        "gulp-sort": "^2.0.0",
         "https-proxy-agent": "^7.0.6",
         "i18next": "^25.2.1",
         "i18next-scanner": "^4.6.0",
@@ -79,25 +76,21 @@
         "license-webpack-plugin": "^4.0.2",
         "map-stream": "^0.0.7",
         "mime-types": "^3.0.1",
-        "ora": "^8.2.0",
         "react": "^19.1.0",
         "react-i18next": "^15.5.2",
         "react-object-model": "^1.2.24",
         "resolve-path": "^1.4.0",
-        "sass": "^1.89.1",
+        "sass": "^1.89.2",
         "sass-loader": "^16.0.5",
         "source-map-loader": "^5.0.0",
         "strip-ansi": "^7.1.0",
         "style-loader": "^4.0.0",
-        "through2": "^4.0.2",
         "tough-cookie": "^5.1.2",
         "ts-loader": "^9.5.2",
         "tslib": "^2.8.1",
         "typescript": "^5.8.3",
         "ua-parser-js": "^2.0.3",
         "undici": "^7.10.0",
-        "vinyl": "^3.0.1",
-        "vinyl-fs": "^4.0.2",
         "webpack": "^5.99.9",
         "webpack-bundle-analyzer": "^4.10.2",
         "ws": "^8.18.2"
@@ -107,17 +100,14 @@
         "@types/archiver": "^6.0.3",
         "@types/babel__traverse": "^7.20.7",
         "@types/eslint": "^9.6.1",
-        "@types/estree": "^1.0.7",
-        "@types/gulp-sort": "^2.0.4",
+        "@types/estree": "^1.0.8",
         "@types/koa": "^2.15.0",
         "@types/koa-compress": "^4.0.6",
-        "@types/mime-types": "^3.0.0",
-        "@types/node": "^22.15.30",
-        "@types/react": "^19.1.6",
-        "@types/through2": "^2.0.41",
+        "@types/mime-types": "^3.0.1",
+        "@types/node": "^24.0.0",
+        "@types/react": "^19.1.7",
         "@types/tough-cookie": "^4.0.5",
         "@types/ua-parser-js": "^0.7.39",
-        "@types/vinyl-fs": "^3.0.6",
         "@types/vscode": "^1.100.0",
         "@types/webpack-bundle-analyzer": "^4.7.0"
     }

package/server.js

@@ -706,9 +706,13 @@ export class Server {
         return fp;
     }
     set_content_type(response, fext) {
-        response.set('content-type', (Server.js_exts.has(fext)
-            ? 'text/javascript; chatset=utf-8'
-            : get_content_type(`file.${fext}`) || 'application/octet-stream'));
+        response.set('content-type', (Server.js_exts.has(fext) ?
+            'text/javascript; chatset=utf-8'
+            :
+                fext === 'mp4' ?
+                    'video/mp4'
+                    :
+                        get_content_type(`file.${fext}`) || 'application/octet-stream'));
     }
     /** - range: 取值为逗号分割的多个可用端口或端口区间 (不能含有空格，包含区间右值)，比如：`8321,8322,8300-8310,11000-11999
         - reverse?: `false` 在 range 内从后往前尝试 */

package/utils.browser.d.ts

@@ -137,3 +137,7 @@ export declare function ceil2(n: number): number;
 export declare function throttle(duration: number, func: Function, delay_first?: boolean): (this: any, ...args: any[]) => void;
 /** 防抖，间隔一段时间不再触发时调用 */
 export declare function debounce(duration: number, func: Function): (this: any, ...args: any[]) => void;
+/** 轮询尝试 action 共 times 次，每次间隔 duration
+    action 返回 trusy 值时认为成功，返回 action 的结果
+    如果次数用尽仍然失败，返回 null */
+export declare function poll<TResult>(duration: number, times: number, action: (breaker: () => void) => Promise<TResult>): Promise<TResult>;

package/utils.browser.js

@@ -461,4 +461,22 @@ export function debounce(duration, func) {
         }, duration);
     };
 }
+/** 轮询尝试 action 共 times 次，每次间隔 duration
+    action 返回 trusy 值时认为成功，返回 action 的结果
+    如果次数用尽仍然失败，返回 null */
+export async function poll(duration, times, action) {
+    let break_flag = false;
+    function _break() {
+        break_flag = true;
+    }
+    for (let i = 0; i < times; ++i) {
+        const result = await action(_break);
+        if (result)
+            return result;
+        if (break_flag)
+            break;
+        await delay(duration);
+    }
+    return null;
+}
 //# sourceMappingURL=utils.browser.js.map

package/utils.d.ts

@@ -1,7 +1,6 @@
 import { Writable, Transform, type Readable, type Duplex, type TransformCallback } from 'stream';
 import util from 'util';
 import type { TimerOptions } from 'timers';
-import type Vinyl from 'vinyl';
 import { type Mapper } from './prototype.ts';
 /** `180` 输出字符宽度 */
 export declare const output_width = 180;
@@ -177,7 +176,7 @@ export declare namespace inspect {
     create an event stream and apply function to each .write,
     emitting each response as data unless it's an empty callback
  */
-export declare function map_stream<Out, In = Vinyl>(mapper: (obj: In, cb: Function) => any, options?: {
+export declare function map_stream<Out, In = any>(mapper: (obj: In, cb: Function) => any, options?: {
     failures?: boolean;
 }): Duplex;
 export declare function stream_to_lines(stream: Readable): AsyncGenerator<string, void, unknown>;
@@ -214,3 +213,7 @@ export declare function ceil2(n: number): number;
 export declare function throttle(duration: number, func: Function, delay_first?: boolean): (this: any, ...args: any[]) => void;
 /** 防抖，间隔一段时间不再触发时调用 */
 export declare function debounce(duration: number, func: Function): (this: any, ...args: any[]) => void;
+/** 轮询尝试 action 共 times 次，每次间隔 duration
+    action 返回 trusy 值时认为成功，返回 action 的结果
+    如果次数用尽仍然失败，返回 null */
+export declare function poll<TResult>(duration: number, times: number, action: (breaker: () => void) => Promise<TResult>): Promise<TResult>;

package/utils.js

@@ -737,4 +737,22 @@ export function debounce(duration, func) {
         }, duration);
     };
 }
+/** 轮询尝试 action 共 times 次，每次间隔 duration
+    action 返回 trusy 值时认为成功，返回 action 的结果
+    如果次数用尽仍然失败，返回 null */
+export async function poll(duration, times, action) {
+    let break_flag = false;
+    function _break() {
+        break_flag = true;
+    }
+    for (let i = 0; i < times; ++i) {
+        const result = await action(_break);
+        if (result)
+            return result;
+        if (break_flag)
+            break;
+        await delay(duration);
+    }
+    return null;
+}
 //# sourceMappingURL=utils.js.map