xshell 1.1.8 → 1.1.10

package/antd.sass

@@ -0,0 +1,43 @@
+.ant-modal-root
+    // 增加 modal 标题下方空白
+    .ant-modal-header
+        margin-bottom: 18px
+    
+    .ant-modal-mask
+        background-color: unset
+    
+    .ant-modal
+        .ant-modal-content
+            padding: 20px
+
+
+@mixin height()
+    .ant-table-wrapper
+        height: 100%
+        
+        .ant-spin-nested-loading
+            height: 100%
+            
+            .ant-spin-container
+                height: 100%
+                display: flex
+                flex-direction: column
+            
+            .ant-table-container
+                height: 100%
+                display: flex
+                flex-direction: column
+                
+                .ant-table-body
+                    position: relative
+                    flex: 1
+                    
+                    table
+                        position: absolute
+                        left: 0
+                        top: 0
+                        right: 0
+                        bottom: 0
+            
+            .ant-table
+                flex: 1

package/file.js

@@ -154,7 +154,10 @@ export async function flist(fpd, options = {}) {
         return _stats;
     }
     if (deep)
-        return (await Promise.all(fps.map(async (fp) => {
+        return (await Promise.all(
+        // 顶层文件/文件夹
+        fps.map(async (fp) => {
+            /** 顶层文件夹的大小 */
             let fpd_stats;
             return fp.isdir ?
                 [
@@ -163,7 +166,9 @@ export async function flist(fpd, options = {}) {
                         if (stats) {
                             if (!absolute)
                                 fp_or_stats.fp = fp + fp_or_stats.fp;
-                            fpd_stats.size += fp_or_stats.size;
+                            // 所有顶层文件夹中的文件（不包括文件夹）大小总和加起来作为文件夹大小
+                            if (!fp_or_stats.fp.isdir)
+                                fpd_stats.size += fp_or_stats.size;
                             return fp_or_stats;
                         }
                         else

package/i18n/dict.json

@@ -382,5 +382,8 @@
     },
     "等待 {{duration}} 秒后重试 request (已尝试 {{_count}} 次) …": {
         "en": "Wait {{duration}} seconds before retrying request (tried {{_count}} times) …"
+    },
+    "fsend 必须传 absolute 选项, sea 选项, 或 fpd_root 文件夹": {
+        "en": "fsend must be passed the absolute option, the sea option, or the fpd_root folder"
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "xshell",
-    "version": "1.1.8",
+    "version": "1.1.10",
     "type": "module",
     "main": "./index.js",
     "bin": {
@@ -57,17 +57,16 @@
         "@svgr/webpack": "^8.1.0",
         "@types/sass-loader": "^8.0.9",
         "@types/ws": "^8.5.13",
-        "@typescript-eslint/eslint-plugin": "^8.18.1",
-        "@typescript-eslint/parser": "^8.18.1",
-        "@typescript-eslint/utils": "^8.18.1",
+        "@typescript-eslint/eslint-plugin": "^8.18.2",
+        "@typescript-eslint/parser": "^8.18.2",
+        "@typescript-eslint/utils": "^8.18.2",
         "@xterm/addon-fit": "^0.10.0",
         "@xterm/addon-web-links": "^0.11.0",
         "@xterm/addon-webgl": "^0.18.0",
         "@xterm/xterm": "^5.5.0",
         "ali-oss": "^6.22.0",
         "archiver": "^7.0.1",
-        "byte-size": "^9.0.1",
-        "chalk": "^5.4.0",
+        "chalk": "^5.4.1",
         "chardet": "^2.0.0",
         "cli-table3": "^0.6.5",
         "cli-truncate": "^4.0.0",
@@ -77,11 +76,11 @@
         "emoji-regex": "^10.4.0",
         "eslint": "^9.17.0",
         "eslint-plugin-import": "^2.31.0",
-        "eslint-plugin-react": "^7.37.2",
+        "eslint-plugin-react": "^7.37.3",
         "gulp-sort": "^2.0.0",
         "hash-string": "^1.0.0",
         "https-proxy-agent": "^7.0.6",
-        "i18next": "^24.1.2",
+        "i18next": "^24.2.0",
         "i18next-scanner": "^4.6.0",
         "koa": "^2.15.3",
         "koa-compress": "^5.1.1",
@@ -92,7 +91,7 @@
         "ora": "^8.1.1",
         "react": "^19.0.0",
         "react-i18next": "^15.2.0",
-        "react-object-model": "^1.2.20",
+        "react-object-model": "^1.2.21",
         "resolve-path": "^1.4.0",
         "sass": "^1.83.0",
         "sass-loader": "^16.0.4",
@@ -117,7 +116,6 @@
         "@types/ali-oss": "^6.16.11",
         "@types/archiver": "^6.0.3",
         "@types/babel__traverse": "^7.20.6",
-        "@types/byte-size": "^8.1.2",
         "@types/chardet": "^0.8.3",
         "@types/eslint": "^9.6.1",
         "@types/estree": "^1.0.6",
@@ -137,7 +135,6 @@
     },
     "pnpm": {
         "patchedDependencies": {
-            "@types/byte-size@8.1.2": "patches/@types__byte-size@8.1.2.patch",
             "koa@2.15.3": "patches/koa@2.15.3.patch"
         }
     }

package/path.d.ts

@@ -1,5 +1,4 @@
 import { default as npath, type FormatInputPathObject } from 'path';
-export declare function to_fp(str: string): string;
 /** Normalize a string path, reducing '..' and '.' parts.
     When multiple slashes are found, they're replaced by a single one; when the path contains a trailing slash, it is preserved.
     @param path string path to normalize.
@@ -55,7 +54,7 @@ export declare function extname(path: string): string;
 /** `/` */
 export declare const sep = "/";
 /** The platform-specific file delimiter. ';' or ':'. */
-export declare const delimiter: ":" | ";";
+export declare const delimiter: ";" | ":";
 /** Returns an object from a path string - the opposite of format().
     @param path path to evaluate.
     @throws {TypeError} if `path` is not a string. */
@@ -67,12 +66,11 @@ export declare function format(pathObject: FormatInputPathObject): string;
     If path is not a string, path will be returned without modifications.
     This method is meaningful only on Windows system.
     On POSIX systems, the method is non-operational and always returns path without modifications. */
-export declare function toNamespacedPath(path: string): any;
+export declare function toNamespacedPath(path: string): string;
 export declare const posix: npath.PlatformPath;
 export declare const win32: npath.PlatformPath;
 /** 统一使用 / 作为分隔符的 path 模块 */
 export declare let path: {
-    to_fp: typeof to_fp;
     normalize: typeof normalize;
     join: typeof join;
     resolve: typeof resolve;
@@ -83,7 +81,7 @@ export declare let path: {
     basename: typeof basename;
     extname: typeof extname;
     sep: string;
-    delimiter: ":" | ";";
+    delimiter: ";" | ":";
     parse: typeof parse;
     format: typeof format;
     toNamespacedPath: typeof toNamespacedPath;

package/path.js

@@ -1,25 +1,16 @@
 import { default as npath } from 'path';
-export function to_fp(str) {
-    if (!str)
-        return str;
-    const fp = str.replaceAll('\\', '/');
-    // 转换小写盘符开头的路径
-    return fp[1] === ':' && 'a' <= fp[0] && fp[0] <= 'z'
-        ? fp[0].toUpperCase() + fp.slice(1)
-        : fp;
-}
 /** Normalize a string path, reducing '..' and '.' parts.
     When multiple slashes are found, they're replaced by a single one; when the path contains a trailing slash, it is preserved.
     @param path string path to normalize.
     @throws {TypeError} if `path` is not a string. */
 export function normalize(path) {
-    return to_fp(npath.normalize(to_fp(path)));
+    return npath.normalize(path).fp;
 }
 /** Join all arguments together and normalize the resulting path.
     @param paths paths to join.
     @throws {TypeError} if any of the path segments is not a string. */
 export function join(...paths) {
-    return to_fp(npath.join(...paths.map(p => to_fp(p))));
+    return npath.join(...paths.map(p => p.fp)).fp;
 }
 /** The right-most parameter is considered {to}. Other parameters are considered an array of {from}.
     
@@ -33,7 +24,7 @@ export function join(...paths) {
     @param paths A sequence of paths or path segments.
     @throws {TypeError} if any of the arguments is not a string. */
 export function resolve(...paths) {
-    return to_fp(npath.resolve(...paths.map(p => to_fp(p))));
+    return npath.resolve(...paths.map(p => p.fp)).fp;
 }
 /** 和 resolve 一样，但是保留最后一个 path 结尾的 / */
 export function resolve_with_slash(...paths) {
@@ -50,20 +41,20 @@ export function resolve_with_slash(...paths) {
     @param path path to test.
     @throws {TypeError} if `path` is not a string. */
 export function isAbsolute(path) {
-    return npath.isAbsolute(to_fp(path));
+    return npath.isAbsolute(path.fp);
 }
 /** Solve the relative path from {from} to {to} based on the current working directory.
     At times we have two absolute paths, and we need to derive the relative path from one to the other. This is actually the reverse transform of path.resolve.
     
     @throws {TypeError} if either `from` or `to` is not a string. */
 export function relative(from, to) {
-    return to_fp(npath.relative(to_fp(from), to_fp(to)));
+    return npath.relative(from.fp, to.fp).fp;
 }
 /** Return the directory name of a path. Similar to the Unix dirname command.
     @param path the path to evaluate.
     @throws {TypeError} if `path` is not a string. */
 export function dirname(path) {
-    return to_fp(npath.dirname(path));
+    return npath.dirname(path.fp).fp;
 }
 /** Return the last portion of a path. Similar to the Unix basename command.
     Often used to extract the file name from a fully qualified path.
@@ -71,7 +62,7 @@ export function dirname(path) {
     @param suffix optionally, an extension to remove from the result.
     @throws {TypeError} if `path` is not a string or if `ext` is given and is not a string. */
 export function basename(path, suffix) {
-    return npath.basename(to_fp(path), suffix);
+    return npath.basename(path.fp, suffix);
 }
 /** Return the extension of the path, from the last '.' to end of string in the last portion of the path.
     If there is no '.' in the last portion of the path or the first character of it is '.', then it returns an empty string.
@@ -79,7 +70,7 @@ export function basename(path, suffix) {
     @param path the path to evaluate.
     @throws {TypeError} if `path` is not a string. */
 export function extname(path) {
-    return npath.extname(to_fp(path));
+    return npath.extname(path.fp);
 }
 /** `/` */
 export const sep = '/';
@@ -89,25 +80,24 @@ export const delimiter = npath.delimiter;
     @param path path to evaluate.
     @throws {TypeError} if `path` is not a string. */
 export function parse(path) {
-    return npath.parse(to_fp(path));
+    return npath.parse(path.fp);
 }
 /** Returns a path string from an object - the opposite of parse().
     @param pathObject path to evaluate. */
 export function format(pathObject) {
-    return to_fp(npath.format(pathObject));
+    return npath.format(pathObject).fp;
 }
 /** On Windows systems only, returns an equivalent namespace-prefixed path for the given path.
     If path is not a string, path will be returned without modifications.
     This method is meaningful only on Windows system.
     On POSIX systems, the method is non-operational and always returns path without modifications. */
 export function toNamespacedPath(path) {
-    return to_fp(toNamespacedPath(to_fp(path)));
+    return npath.toNamespacedPath(path.fp).fp;
 }
 export const posix = npath.posix;
 export const win32 = npath.win32;
 /** 统一使用 / 作为分隔符的 path 模块 */
 export let path = {
-    to_fp,
     normalize,
     join,
     resolve,

package/process.d.ts

@@ -2,6 +2,7 @@ import { type ChildProcess } from 'child_process';
 import './prototype.ts';
 import type { Encoding } from './file.ts';
 import type { MyProxy } from './net.ts';
+import { inspect } from './utils.ts';
 export declare const sea: boolean;
 export declare const exe_nodejs: string;
 export declare const platform: NodeJS.Platform;
@@ -97,19 +98,25 @@ export interface CallResult<TOutput extends string | Buffer = string> {
     stderr: TOutput;
     code: number | null;
     signal: NodeJS.Signals | null;
+    command: string;
+    message: string;
     child: ChildProcess;
+    print: FullPrintOptions;
 }
-export interface CallError<TOutput extends string | Buffer = string> {
-    result: {
-        pid: number;
-        stdout: TOutput;
-        stderr: TOutput;
-        code: number;
-        signal: NodeJS.Signals;
-        child: ChildProcess;
-    };
+export declare class CallError<TOutput extends string | Buffer = string> extends Error {
+    name: string;
+    pid: number;
+    stdout: TOutput;
+    stderr: TOutput;
+    code: number;
+    signal: NodeJS.Signals;
+    command: string;
+    child: ChildProcess;
+    print: FullPrintOptions;
+    constructor({ message, pid, stdout, stderr, code, signal, command, child, print }: CallResult<TOutput>);
+    [inspect.custom](): string;
 }
-/** 调用可执行文件，获取返回结果
+/** 调用可执行文件，获取返回结果，错误时抛出 CallError
     - exe: .exe 路径或文件名 (建议使用路径，跳过 path 搜索，性能更高)
     - args: `[ ]` 参数列表
     - options?:
@@ -122,6 +129,9 @@ export interface CallError<TOutput extends string | Buffer = string> {
         - stdio?: `'pipe'` 设置为 'ignore' 时忽略 stdio 处理
         - input?: string, 启动子进程之后写入到子进程 stdin 中的内容，写完后关闭子进程 stdin
         - on_child?: 可以传入回调函数及时获取通过 start 创建的子进程，便于执行 kill、获得 pid 等操作 */
+export declare function call(exe: string, args: string[], options: CallOptions & {
+    encoding: 'binary';
+}): Promise<CallResult<Buffer>>;
 export declare function call(exe: string, args?: string[], options?: CallOptions): Promise<CallResult<string>>;
 export interface CallNodeJsOptions extends CallOptions {
     inspect?: number | true;

package/process.js

@@ -9,12 +9,6 @@ export const platform = os.platform();
 export const username = os.userInfo().username;
 export const noprint = { print: false };
 export const print_no_command = { print: { command: false, code: false, stdout: true, stderr: true } };
-function get_command(exe, args) {
-    return (short_exe_names[exe] || exe.quote_if_space()) +
-        (args.length
-            ? ' ' + args.map(arg => arg.quote_if_space()).join(' ')
-            : '');
-}
 async function prepare_spawn(detached, exe, args, { cwd, window: _window = true, envs, 
 // @ts-ignore
 input, fp_stdin, fp_stdout, fp_stderr, print = true, proxy, 
@@ -84,9 +78,15 @@ stdio }) {
             stdout: print,
             stderr: print
         };
-    let command;
+    const command = (short_exe_names[exe] || exe.quote_if_space()) +
+        (args.length
+            ? ' ' +
+                args
+                    .map(arg => arg.quote_if_space())
+                    .join(' ')
+            : '');
     if (print.command)
-        console.log((command = get_command(exe, args)).blue);
+        console.log(command.blue);
     return {
         print,
         command,
@@ -126,8 +126,35 @@ export async function start(exe, args = [], options = {}) {
             await close_all_handles();
     }
 }
+export class CallError extends Error {
+    name = 'CallError';
+    pid;
+    stdout;
+    stderr;
+    code;
+    signal;
+    command;
+    child;
+    print;
+    constructor({ message, pid, stdout, stderr, code, signal, command, child, print }) {
+        super(message);
+        this.pid = pid;
+        this.stdout = stdout;
+        this.stderr = stderr;
+        this.code = code;
+        this.signal = signal;
+        this.command = command;
+        this.child = child;
+        this.print = print;
+    }
+    [inspect.custom]() {
+        return (!this.print.stdout && this.stdout ? `标准输出:\n${this.stdout}\n` : '') +
+            (!this.print.stderr && this.stderr ? `标准错误:\n${this.stderr}\n` : '') +
+            this.stack;
+    }
+}
 export async function call(exe, args = [], options = {}) {
-    const { print, command, spawn_options, close_all_handles } = await prepare_spawn(false, exe, args, options);
+    const { print, spawn_options, close_all_handles, command } = await prepare_spawn(false, exe, args, options);
     let child;
     try {
         child = spawn(exe, args, spawn_options);
@@ -191,14 +218,11 @@ export async function call(exe, args = [], options = {}) {
             resolve();
         });
     });
-    let message;
-    const code_error = throw_code && (code || signal);
-    if (print.code || code_error) {
-        message = `进程 ${command || get_command(exe, args)} ` + (code
-            ? `${throw_code ? '异常' : ''}结束，退出码: ${code}${signal ? `，信号: ${signal}` : ''}`
-            : '正常结束');
-        console.log(message[code_error ? 'red' : 'blue']);
-    }
+    const message = `进程 ${command} ` + (code
+        ? `${throw_code ? '异常' : ''}结束，退出码: ${code}${signal ? `，信号: ${signal}` : ''}`
+        : '正常结束');
+    if (print.code && !code)
+        console.log(message.blue);
     const result = {
         pid: child.pid,
         stdout: encoding === 'binary'
@@ -209,16 +233,28 @@ export async function call(exe, args = [], options = {}) {
             : stderrs.join(''),
         code,
         signal,
+        command,
+        message,
         child,
+        print,
         [inspect.custom]() {
-            return inspect(this, { omit: ['child'] });
+            return inspect(this, {
+                omit: [
+                    'child',
+                    'message',
+                    'command',
+                    'code',
+                    'signal',
+                    'pid',
+                    'print',
+                    ...print.stdout ? ['stdout'] : [],
+                    ...print.stderr ? ['stderr'] : [],
+                ]
+            });
         }
     };
-    if (code_error) {
-        let error = new Error(message);
-        error.result = result;
-        throw error;
-    }
+    if (throw_code && (code || signal))
+        throw new CallError(result);
     return result;
 }
 /** 调用 node <js> 并等待结果

package/prototype.browser.d.ts

@@ -57,10 +57,11 @@ declare global {
             
             - preservations?: `''` 保留的正则表达式字符
             - flags?: `''` 正则匹配选项
-            - pattern_placeholder?: `/\{.*?\}/g`
-        */
+            - pattern_placeholder?: `/\{.*?\}/g` */
         find(this: string, pattern: string, preservations?: string, flags?: string, pattern_placeholder?: RegExp): Record<string, string>;
-        /** - type?: `'single'` */
+        /** 查找子串或字符出现的次数 */
+        count(this: string, search: string): number;
+        /** - type?: `'single'` 引号类型 */
         quote(this: string, type?: keyof typeof quotes | 'psh'): string;
         /** - shape?: `'parenthesis'` */
         bracket(this: string, shape?: keyof typeof brackets): string;
@@ -103,17 +104,25 @@ declare global {
         slice_to(this: string, search: string, options?: SliceOptions): string;
         /** 等价于 .endsWith('/') */
         isdir: boolean;
-        /** 以 `/` 分割的路径，可能以 / 结尾 */
+        /** 转换为以 `/` 分割的路径，可能以 / 结尾 */
         fp: string;
-        /** 以 `/` 分割的文件夹路径，一定以 / 结尾 */
+        /** 转换为以 `/` 分割的文件夹路径，一定以 / 结尾 */
         fpd: string;
-        /** 父文件夹路径 (path.dirname)，一定以 `/` 结尾 */
+        /** 父文件夹路径，一定以 `/` 结尾，或为空
+            特殊情况:
+            - '/'.fdir === ''
+            - 'D:/'.fdir === '' */
         fdir: string;
-        /** 文件名 (path.basename 的结果), 保留结尾的 /，如:
+        /** 文件或文件夹名, 保留结尾的 /
+            常规情况:
             - D:/0/aaa.txt -> aaa.txt
-            - D:/aaa/ -> aaa/ */
+            - D:/aaa/ -> aaa/
+            特殊情况:
+            - '/'.fname === '/'
+            - 'D:/'.fname === 'D:/' */
         fname: string;
-        /** .txt */
+        /** 文件后缀名，不带点，如: txt, zip，没有后缀时返回空字符串
+            特殊情况: .aaa 的 fext 为 '' */
         fext: string;
     }
     interface Date {
@@ -134,8 +143,8 @@ declare global {
         to_formal_str(this: Date, ms?: boolean): string;
     }
     interface Number {
-        /** 12.4 KB (1 KB = 1024 B) */
-        to_fsize_str(this: number, units?: 'iec' | 'metric'): string;
+        /** 12.4 kb (1 kb = 1024 b) */
+        to_fsize_str(this: number): string;
         to_bin_str(this: number): string;
         /** 转换为 0x???? 这样的十六进制形式
             - length?: 位数自动对齐到 4 的倍数 */
@@ -146,15 +155,15 @@ declare global {
         /** 等价于 .at(-1) */
         last: T;
         indent(this: string[], width?: number, c?: string): string[];
-        /** 对数组中所有元素求和 (+), 返回结果 */
-        sum(this: T[]): T;
-        /** 查找数组中最大的元素，可传入 selector 选择某个属性，或者计算出某个值，用作大小比较 */
-        max(this: T[], selector?: keyof T | KeySelector<T>): T;
-        /** 查找数组中最小的元素，可传入 selector 选择某个属性，或者计算出某个值，用作大小比较 */
-        min(this: T[], selector?: keyof T | KeySelector<T>): T;
-        /** 去除重复元素（可按 selector 去重），重复值保留最后出现的那个
-            - selector?: 可以是 key (string, number, symbol) 或 (obj: any) => any */
-        unique(this: T[], selector?: keyof T | KeySelector<T>): T[];
+        /** 对数组中所有元素求和 (+), 返回结果，可传入 mapper 计算出某个值，用作求和 */
+        sum<TReturn = T>(this: T[], mapper?: keyof T | Mapper<T>): TReturn;
+        /** 查找数组中最大的元素，可传入 mapper 计算出某个值，用作大小比较 */
+        max(this: T[], mapper?: keyof T | Mapper<T>): T;
+        /** 查找数组中最小的元素，可传入 mapper 计算出某个值，用作大小比较 */
+        min(this: T[], mapper?: keyof T | Mapper<T>): T;
+        /** 去除重复元素（可按 mapper 选择或计算某个值来去重），重复值保留最后出现的那个
+            - mapper?: 可以是 key (string, number, symbol) 或 (obj: any) => any */
+        unique(this: T[], mapper?: keyof T | Mapper<T>): T[];
         /**
             - trim_line?: `true`
             - rm_empty_lines?: `true`
@@ -169,13 +178,15 @@ declare global {
         join_lines(append?: boolean): string;
     }
     interface BigInt {
+        /** 12.4 kb (1 kb = 1024 b) */
+        to_fsize_str(this: bigint): string;
         toJSON(this: bigint): string;
     }
     interface Error {
         toJSON(this: Error): string;
     }
     interface Set<T> {
-        map<TResult>(mapfn: (value: T, index: number) => TResult): TResult[];
+        map<TResult>(mapper: (value: T, index: number) => TResult): TResult[];
     }
 }
 interface SliceOptions {
@@ -185,8 +196,8 @@ interface SliceOptions {
 export declare const emoji_regex: RegExp;
 export declare const noop: () => void;
 export declare const ident: <T>(x: T) => T;
-export declare const build_selector: <TObj>(key: keyof TObj) => (obj: TObj) => TObj[keyof TObj];
-export type KeySelector<TObj = any, TKey extends keyof TObj = keyof TObj> = (key: TObj) => TObj[TKey];
+export declare const build_mapper: <TObj>(key: keyof TObj) => (obj: TObj) => TObj[keyof TObj];
+export type Mapper<TObj = any, TKey extends keyof TObj = keyof TObj> = (obj: TObj) => TObj[TKey];
 /** value 不为 null 或 undefined */
 export declare const not_empty: (value: any) => boolean;
 export declare const empty: (value: any) => boolean;
@@ -215,4 +226,5 @@ export declare const brackets: {
 };
 export declare function to_json(obj: any, replacer?: any): string;
 export declare function is_codepoint_fullwidth(codepoint: number): boolean;
+export declare function byte_size(bytes: number | bigint): string;
 export {};