xshell 1.3.52 → 1.3.54

package/file.d.ts

@@ -109,27 +109,36 @@ export type FStats = fs.BigIntStats & {
 };
 export interface FListOptions {
     filter?: RegExp | ((fp: string) => any);
+    excludes?: string[] | Set<string>;
     deep?: boolean;
     absolute?: boolean;
     print?: boolean;
     stats?: boolean;
     best_effort?: boolean;
+    limit?: number;
+}
+interface FListContext {
+    count: number;
+    fpd: string;
+    excludes?: Set<string>;
 }
 /** 列出文件夹，默认返回文件名列表，也可以传入 stats 选项返回元数据
-    - fpd: 文件夹完整路径 absolute path of directory
+    - fpd: 文件夹完整路径
     - options?:
-        - deep?: `false` 递归遍历 recursively
-        - absolute?: `false` 返回、打印完整路径而不是相对路径，为 false 时返回的 FStats.fp 也会被修改 Return, print full path instead of relative path, FStats.fp returned when false will also be modified
+        - deep?: `false` 递归遍历
+        - absolute?: `false` 返回、打印完整路径而不是相对路径，为 false 时返回的 FStats.fp 也会被修改
         - print?: `true`
         - filter?: `() => true`  RegExp | (fp: string) => any
             注意当 deep = true 时被 filter 过滤掉的目录及目录中的文件不会包含在结果中
+        - excludes?: 如 ['.git/', 'node_modules/'], 指定忽略的文件、文件夹名称
         - stats?: `false` 启用后返回 FStats 列表
-        - best_effort?: `false` 启用后，当遇到 stat 软链接文件不存在等错误时，会返回一个 fake_time FStats 文件，而不是抛出错误 */
+        - best_effort?: `false` 启用后，当遇到 stat 软链接文件不存在等错误时，会返回一个 fake_time FStats 文件，而不是抛出错误
+        - limit?: 递归模式下限制最大列出的文件数，达到限制后不再往更深层次递归读取文件夹 */
 export declare function flist(fpd: string): Promise<string[]>;
 export declare function flist(fpd: string, options?: FListOptions & {
     stats: true;
-}): Promise<FStats[]>;
-export declare function flist(fpd: string, options?: FListOptions): Promise<string[]>;
+}, ctx?: FListContext): Promise<FStats[]>;
+export declare function flist(fpd: string, options?: FListOptions, ctx?: FListContext): Promise<string[]>;
 export declare function fstat(fp: string | FileHandle): Promise<FStats>;
 export declare function flstat(fp: string): Promise<FStats>;
 export declare function ffstat(handle: fsp.FileHandle): Promise<fs.BigIntStats>;

package/file.js

@@ -169,14 +169,13 @@ const fake_stats = {
     ctime: fake_time,
     birthtime: fake_time,
 };
-export async function flist(fpd, options = {}) {
-    const { filter, deep = false, absolute = false, print = true, stats = false, best_effort = false } = options;
-    check(path.isAbsolute(fpd), t("flist: 参数 fpd: '{{fpd}}' 必须是绝对路径", { fpd }));
-    check(fpd.isdir, t("flist: 参数 fpd: '{{fpd}}' 必须以 / 结尾", { fpd }));
-    if (!path.isAbsolute(fpd))
-        throw new Error(t('参数 fpd: ') + fpd + t(' 必须是绝对路径'));
-    if (!fpd.isdir)
-        throw new Error(t('参数 fpd: ') + fpd + t(' 必须以 / 结尾'));
+export async function flist(fpd, options = {}, ctx = { count: 0, fpd }) {
+    const { filter, deep = false, absolute = false, print = true, stats = false, best_effort = false, limit, excludes } = options;
+    check(path.isAbsolute(fpd), `flist: 参数 fpd: '${fpd}' 必须是绝对路径`);
+    check(fpd.isdir, `flist: 参数 fpd: '${fpd}' 必须以 / 结尾`);
+    // 初始化 ctx.excludes
+    if (excludes)
+        ctx.excludes ??= Array.isArray(excludes) ? new Set(excludes) : excludes;
     // readdir withFileTypes 参数在底层有什么区别，速度上有什么差异
     // 都调用了 uv_fs_scandir, 且调用参数相同，仅仅是 Node.js 侧的回调不同 AfterScanDir / AfterScanDirWithTypes
     // 回调中通过 uv_fs_scandir_next 获取到每个条目的信息，而 uv_fs_scandir_next 中都会读取 type
@@ -184,63 +183,55 @@ export async function flist(fpd, options = {}) {
     const files = await fsp.readdir(fpd, { withFileTypes: true, encoding: 'utf-8' });
     const filter_regexp = filter instanceof RegExp;
     const filter_fn = Boolean(filter && !filter_regexp);
-    let fps = [];
+    let rfps = [];
     for (const file of files) {
-        const fp = (absolute ? fpd : '') +
-            file.name +
-            (file.isDirectory() ? '/' : '');
-        if (filter_regexp && !filter.test(fp))
-            continue;
-        if (filter_fn && !filter(fp))
+        const fname = file.name + (file.isDirectory() ? '/' : '');
+        const rfp = deep ? (fpd + fname).strip_start(ctx.fpd) : fname;
+        if (ctx.excludes?.has(rfp) ||
+            filter_regexp && !filter.test(rfp) ||
+            filter_fn && !filter(rfp))
             continue;
         if (print)
-            console.log(fp);
-        fps.push(fp);
+            console.log(absolute ? ctx.fpd + rfp : rfp);
+        rfps.push(rfp);
+        if (limit)
+            ++ctx.count;
     }
-    async function _fstat(fp) {
+    async function _fstat(rfp) {
+        const fp = ctx.fpd + rfp;
         let _stats;
         try {
-            _stats = await fstat(absolute ? fp : fpd + fp);
+            _stats = await fstat(fp);
         }
         catch (error) {
-            if (best_effort)
-                _stats = { ...fake_stats };
-            else
+            if (!best_effort)
                 throw error;
+            _stats = { ...fake_stats };
         }
-        if (!absolute)
-            _stats.fp = fp;
+        _stats.fp = absolute ? fp : rfp;
         return _stats;
     }
-    if (deep)
-        return (await Promise.all(
+    let results = !deep ?
+        stats ? await Promise.all(rfps.map(_fstat)) : rfps
+        : (await Promise.all(
         // 顶层文件/文件夹
-        fps.map(async (fp) => {
+        rfps.map(async (rfp) => {
+            if (!rfp.isdir || limit && ctx.count >= limit)
+                return stats ? _fstat(rfp) : rfp;
             /** 顶层文件夹的大小 */
             let fpd_stats;
-            return fp.isdir ?
-                [
-                    stats ? (fpd_stats = await _fstat(fp)) : fp,
-                    ...(await flist(absolute ? fp : fpd + fp, options)).map((fp_or_stats) => {
-                        if (stats) {
-                            if (!absolute)
-                                fp_or_stats.fp = fp + fp_or_stats.fp;
-                            // 所有顶层文件夹中的文件（不包括文件夹）大小总和加起来作为文件夹大小
-                            if (!fp_or_stats.fp.isdir)
-                                fpd_stats.size += fp_or_stats.size;
-                            return fp_or_stats;
-                        }
-                        else
-                            return absolute ? fp_or_stats : fp + fp_or_stats;
-                    })
-                ]
-                :
-                    stats ? _fstat(fp) : fp;
+            const self = stats ? (fpd_stats = await _fstat(rfp)) : rfp;
+            const children = await flist(ctx.fpd + rfp, options, ctx);
+            if (stats)
+                children.forEach(s => {
+                    fpd_stats.size += s.size;
+                });
+            return [self, ...children];
         }))).flat();
-    else if (stats)
-        return Promise.all(fps.map(_fstat));
-    else
-        return fps;
+    return absolute && fpd === ctx.fpd && !stats ?
+        results.map(rfp => ctx.fpd + rfp)
+        :
+            results;
 }
 export async function fstat(fp) {
     let stat;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "xshell",
-    "version": "1.3.52",
+    "version": "1.3.54",
     "type": "module",
     "main": "./index.js",
     "bin": {
@@ -23,7 +23,6 @@
         "publish:npm": "npm publish --access=public",
         "publish:extension": "vsce publish"
     },
-    "author": "ShenHongFei <shen.hongfei@outlook.com> (https://github.com/ShenHongFei)",
     "publisher": "ShenHongFei",
     "homepage": "https://www.npmjs.com/package/xshell",
     "icon": "xshell.png",
@@ -56,15 +55,15 @@
         "@stylistic/eslint-plugin": "^5.10.0",
         "@svgr/webpack": "^8.1.0",
         "@types/sass-loader": "^8.0.10",
-        "@typescript-eslint/eslint-plugin": "^8.58.0",
-        "@typescript-eslint/parser": "^8.58.0",
-        "@typescript-eslint/utils": "^8.58.0",
+        "@typescript-eslint/eslint-plugin": "^8.58.1",
+        "@typescript-eslint/parser": "^8.58.1",
+        "@typescript-eslint/utils": "^8.58.1",
         "archiver": "^7.0.1",
         "chalk": "^5.6.2",
         "commander": "^14.0.3",
         "css-loader": "^7.1.4",
         "emoji-regex": "^10.6.0",
-        "eslint": "^10.1.0",
+        "eslint": "^10.2.0",
         "eslint-plugin-react": "^7.37.5",
         "https-proxy-agent": "^9.0.0",
         "i18next": "25.8.1",
@@ -77,16 +76,16 @@
         "react": "^19.2.4",
         "react-i18next": "^17.0.2",
         "resolve-path": "^1.4.0",
-        "sass": "^1.98.0",
+        "sass": "^1.99.0",
         "sass-loader": "^16.0.7",
         "source-map-loader": "^5.0.0",
         "strip-ansi": "^7.2.0",
         "style-loader": "^4.0.0",
         "tough-cookie": "^6.0.1",
-        "ts-loader": "^9.5.4",
+        "ts-loader": "^9.5.7",
         "tslib": "^2.8.1",
         "typescript": "^6.0.2",
-        "undici": "^7.24.7",
+        "undici": "^8.0.2",
         "webpack": "^5.105.4",
         "webpack-bundle-analyzer": "^5.3.0",
         "ws": "^8.20.0"
@@ -100,7 +99,7 @@
         "@types/koa": "^3.0.2",
         "@types/koa-compress": "^4.0.7",
         "@types/mime-types": "^3.0.1",
-        "@types/node": "^25.5.0",
+        "@types/node": "^25.5.2",
         "@types/react": "^19.2.14",
         "@types/tough-cookie": "^4.0.5",
         "@types/vscode": "^1.110.0",

package/prototype.common.d.ts

@@ -76,6 +76,7 @@ declare global {
         rm(this: string, pattern: string | RegExp, flags?: string): string;
         /** 将 string 划分为行，并去掉最后一个 \n 之后的 '' */
         split_lines(this: string): string[];
+        /** 将一行 string 解析为缩进量和内容 */
         split_indent(this: string): {
             indent: number;
             text: string;

package/xlint.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import { builtinModules } from 'node:module';
-import { AST_TOKEN_TYPES, ASTUtils, TSESTree } from '@typescript-eslint/utils';
+import { AST_TOKEN_TYPES, AST_NODE_TYPES, ASTUtils } from '@typescript-eslint/utils';
 import TSParser from '@typescript-eslint/parser';
 import ts_plugin from '@typescript-eslint/eslint-plugin';
 import react_plugin from 'eslint-plugin-react';
@@ -327,7 +327,7 @@ export const xlint_plugin = {
                 function checkForTypeAnnotationSpace(typeAnnotation) {
                     const types = typeAnnotation.types;
                     types.forEach(type => {
-                        const skipFunctionParenthesis = type.type === TSESTree.AST_NODE_TYPES.TSFunctionType ? ASTUtils.isNotOpeningBraceToken : 0;
+                        const skipFunctionParenthesis = type.type === AST_NODE_TYPES.TSFunctionType ? ASTUtils.isNotOpeningBraceToken : 0;
                         const operator = sourceCode.getTokenBefore(type, skipFunctionParenthesis);
                         if (operator && unions.includes(operator.value)) {
                             const prev = sourceCode.getTokenBefore(operator);
@@ -735,7 +735,7 @@ export const xlint_plugin = {
                                 let type;
                                 // 收集所有排序后的 import 文本
                                 const texts = imports_.map((im, i) => {
-                                    const [start, end] = get_range_with_comments(source, im.node);
+                                    const [start, end] = get_node_range_with_comments(source, im.node, true);
                                     if (start < _start)
                                         _start = start;
                                     if (end > _end)
@@ -927,26 +927,26 @@ function all_space(str, len = str.length) {
             return false;
     return true;
 }
-/** 获取节点前面的注释，并计算包含注释的范围 */
-function get_range_with_comments(source, node) {
+/** 获取节点及其注释的范围（排除前一条语句的行尾注释）
+    返回 `[start, end]`，其中 start 是第一个独立注释的位置（若无则为节点起始位置）
+    - source
+    - node
+    - include_after_comment?: `true` 是否包含节点后面的行尾注释 */
+function get_node_range_with_comments(source, node, include_after_comment) {
     let [start, end] = node.range;
     // 获取节点前的所有注释
-    let comments = source.getCommentsBefore(node);
+    const comments = source.getCommentsBefore(node);
     if (comments.length !== 0) {
-        // 从最后一个注释往前找，遇到属于上一条语句的行尾注释或非注释时退出
+        // 从最后一个注释往前找，遇到前一条语句行尾注释时退出
         // 判断标准：独立注释以多个空格 + // 或者 /* 开头
         // 行尾注释：// 前面含有非空格
         let valid_comment;
         for (let i = comments.length - 1; i >= 0; --i) {
-            let comment = comments[i];
+            const comment = comments[i];
             // 获取 comment 所在行的内容
-            let line = source.lines[comment.loc.start.line - 1];
+            const line = source.lines[comment.loc.start.line - 1];
             // 找到注释开始标记 // 或 /* 在行中的位置
-            let istart;
-            if (comment.type === 'Line')
-                istart = line.indexOf('//');
-            else // Block
-                istart = line.indexOf('/*');
+            const istart = comment.type === 'Line' ? line.indexOf('//') : line.indexOf('/*');
             // 注释标记之前是否全是空格
             if (!all_space(line.slice(0, istart)))
                 break;
@@ -956,10 +956,12 @@ function get_range_with_comments(source, node) {
         if (valid_comment)
             start = valid_comment.range[0];
     }
-    let comments_ = source.getCommentsAfter(node);
-    // 和导入在同一行，在尾部的注释
-    if (comments_[0]?.loc.start.line === node.loc.end.line)
-        end = comments_[0].range[1];
+    if (include_after_comment) {
+        const comments_after = source.getCommentsAfter(node);
+        // 和节点在同一行，在尾部的注释
+        if (comments_after[0]?.loc.start.line === node.loc.end.line)
+            end = comments_after[0].range[1];
+    }
     return [start, end];
 }
 let cache_alias_cwd;