xshell 1.0.196 → 1.0.199

package/Terminal.d.ts

@@ -7,6 +7,7 @@ export declare function Terminal({ font }: {
     font: string;
 }): import("react/jsx-runtime").JSX.Element;
 declare class TerminalModel extends Model<TerminalModel> {
+    pterm: import("./utils.browser.ts").Deferred<XTerminal>;
     term: XTerminal;
     fit_addon: FitAddon;
     stdio_id: number;

package/Terminal.js

@@ -8,7 +8,7 @@ import { WebLinksAddon } from '@xterm/addon-web-links';
 // 没有 ui
 // import { SearchAddon } from '@xterm/addon-search'
 import { Model } from 'react-object-model';
-import { assert, genid } from './utils.browser.js';
+import { assert, defer, genid } from './utils.browser.js';
 export function Terminal({ font }) {
     let rterminal = useRef();
     useEffect(() => {
@@ -34,14 +34,17 @@ export function Terminal({ font }) {
             term.loadAddon(link_addon);
             // term.loadAddon(search_addon)
             term.open(rterminal.current);
-            term.loadAddon(new WebglAddon());
+            if (document.createElement('canvas').getContext('webgl2'))
+                term.loadAddon(new WebglAddon());
             fit_addon.fit();
+            terminal.pterm.resolve(term);
             terminal.set({ term, fit_addon });
         })();
     }, []);
     return _jsx("div", { className: 'term', ref: rterminal });
 }
 class TerminalModel extends Model {
+    pterm = defer();
     term;
     fit_addon;
     stdio_id = 0;

package/apps.js

@@ -1,6 +1,6 @@
 import util from 'util';
 import { call_nodejs, platform, username } from './process.js';
-import { assert } from './utils.js';
+import { check } from './utils.js';
 import { path } from './path.js';
 export let npm = {
     bin: platform == 'win32' ? `C:/Users/${username}/AppData/Roaming/npm/node_modules/pnpm/bin/pnpm.cjs` : '/usr/bin/pnpm',
@@ -68,11 +68,11 @@ export let oss = {
             - cdn?: `false` false 时返回 oss 链接，true 时返回 cdn 链接
             - copy?: `false` 是否复制到剪贴板 */
     async upload(fp_remote, data, { private: _private = false, print = true, cdn = false, } = {}) {
-        assert(this.client, 'OSS 应该已经初始化了');
-        assert(!fp_remote.startsWith('/'), 'fp 不能以 / 开头');
-        assert(!fp_remote.isdir, '不能使用 oss.upload 上传文件夹，请使用 oss.upload_dir');
+        check(this.client, 'OSS 应该已经初始化了');
+        check(!fp_remote.startsWith('/'), 'fp 不能以 / 开头');
+        check(!fp_remote.isdir, '不能使用 oss.upload 上传文件夹，请使用 oss.upload_dir');
         if (typeof data === 'string')
-            assert(path.isAbsolute(data), 'oss.upload 传入 data 参数类型为 string 时，必须为本地文件完整路径');
+            check(path.isAbsolute(data), 'oss.upload 传入 data 参数类型为 string 时，必须为本地文件完整路径');
         if (data instanceof Uint8Array && !Buffer.isBuffer(data))
             data = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
         await this.client.put(fp_remote, data);
@@ -89,7 +89,7 @@ export let oss = {
     },
     /** 获取经过签名后可访问的 url */
     async get_url(fp) {
-        assert(this.client, 'OSS 应该已经初始化了');
+        check(this.client, 'OSS 应该已经初始化了');
         const url = new URL(this.client.signatureUrl(fp, { expires: /* 十年 */ 3600 * 24 * 365 * 10 }));
         const url_ = `${this.fpd_cdn}${url.pathname.slice(1)}${url.search}`;
         return url_;

package/builder.js

@@ -1,6 +1,6 @@
 import { fileURLToPath } from 'url';
 import { noprint } from './process.js';
-import { Lock, Timer, assert, filter_values, not_empty } from './utils.js';
+import { Lock, check, filter_values, not_empty } from './utils.js';
 import { fcopy, fmkdir, fwrite } from './file.js';
 import { path } from './path.js';
 const monaco_files = [
@@ -172,7 +172,7 @@ export class Bundler {
         this.globals = globals;
         this.exclude_modules = exclude_modules;
         if (dependencies) {
-            assert(target === 'web');
+            check(target === 'web');
             this.dependencies = dependencies;
         }
         if (expose && commonjs2)
@@ -307,6 +307,7 @@ export class Bundler {
                                     // https://webpack.js.org/loaders/sass-loader
                                     loader: get_loader('sass-loader'),
                                     options: {
+                                        api: 'modern-compiler',
                                         ...sass ? {
                                             implementation: sass
                                         } : {},
@@ -393,7 +394,6 @@ export class Bundler {
         };
     }
     async build(print = true) {
-        let timer = new Timer();
         if (!this.lcompiler) {
             const { default: Webpack } = await import('webpack');
             this.config.plugins = [
@@ -447,8 +447,8 @@ export class Bundler {
         if (print) {
             const statstr = stats.toString(this.config.stats)
                 .replace(new RegExp(`\\n\\s*.*${this.name}.* compiled .*successfully.* in (.*)`), '').trimEnd();
-            console.log(`${statstr ? `${statstr}\n` : ''}` +
-                `${this.name} 构建成功, 用时 ${timer.getstr()}`.green);
+            console.log((statstr ? `${statstr}\n` : '') +
+                `${this.name} 成功构建到 ${this.fpd_out}`.green);
         }
     }
     async close() {
@@ -512,8 +512,8 @@ export class Bundler {
             if (print.files)
                 console.log(`已构建 ${fp_html}`);
         }));
-        if (print.info)
-            console.log(`${this.name}.htmls 已构建完成`);
+        if (print.files)
+            console.log(`${this.name} 的所有 html 页面构建完成`);
     }
     resolve_dependencies(dependency_ids = this.dependencies, resolveds = new Set()) {
         dependency_ids.forEach(id => {
@@ -541,8 +541,8 @@ export class Bundler {
         }).flat();
     }
     async copy_files({ dependencies = this.dependencies, production = this.production, assets = this.assets, fpd_root = this.fpd_root, fpd_out = this.fpd_out, print = { info: true, files: false } } = {}) {
-        if (print.info)
-            console.log(`复制 ${this.name} 项目文件及依赖 -> ${this.fpd_out}`);
+        if (print.files)
+            console.log(`复制 ${this.name} 的依赖文件到 ${this.fpd_out}`);
         if (dependencies.length)
             await fmkdir(`${fpd_out}vendors/`, { print: false });
         // 输出路径 -> 原路径，用来保证只复制一次且是同样的映射

package/file.js

@@ -3,7 +3,7 @@ import { isUint8Array } from 'util/types';
 import { path } from './path.js';
 import { t } from './i18n/instance.js';
 import { to_json } from './prototype.js';
-import { assert, Lock, WritableMemoryStream } from './utils.js';
+import { check, Lock, WritableMemoryStream } from './utils.js';
 export { fsp };
 export const encodings = ['utf-8', 'gb18030', 'shift-jis', 'utf-16le'];
 export const ramdisk = fexists('T:/TEMP/', { print: false });
@@ -31,12 +31,12 @@ export async function fopen(fp, flags = 'r', { mode, print } = {}) {
 }
 export async function fread(fp, { dir, encoding = 'utf-8', print = true } = {}) {
     if (dir) {
-        assert(dir.isdir, t('dir 必须以 / 结尾'));
+        check(dir.isdir, t('dir 必须以 / 结尾'));
         fp = dir + fp;
     }
-    assert(!fp.isdir, t('fp 必须是文件，不能以 / 结尾'));
-    assert(path.isAbsolute(fp), `${t('fp 必须是绝对路径:')} ${fp}`);
-    assert(encoding !== 'auto');
+    check(!fp.isdir, t('fp 必须是文件，不能以 / 结尾'));
+    check(path.isAbsolute(fp), `${t('fp 必须是绝对路径:')} ${fp}`);
+    check(encoding !== 'auto');
     if (print)
         console.log(t('读取'), fp);
     switch (encoding) {
@@ -82,7 +82,7 @@ export async function fwrite(fp, data, { print = true } = {}) {
             console.log(t('写入'), fp.fp);
     }
     else {
-        assert(path.isAbsolute(fp), `${t('fp 必须是绝对路径，当前为:')} ${fp}`);
+        check(path.isAbsolute(fp), `${t('fp 必须是绝对路径，当前为:')} ${fp}`);
         if (print)
             console.log(t('写入'), fp);
     }
@@ -103,10 +103,10 @@ export async function fwrite(fp, data, { print = true } = {}) {
 }
 /** 追加内容到文件末尾，如果文件不存在会自动创建 */
 export async function fappend(fp, data, { print = true } = {}) {
-    assert(path.isAbsolute(fp), `${t('fp 必须是绝对路径，当前为:')} ${fp}`);
+    check(path.isAbsolute(fp), `${t('fp 必须是绝对路径，当前为:')} ${fp}`);
     if (print)
         console.log(t('追加'), fp);
-    assert(isUint8Array(data) || typeof data === 'string');
+    check(isUint8Array(data) || typeof data === 'string');
     try {
         await fsp.appendFile(fp, data);
     }
@@ -121,8 +121,8 @@ export async function fappend(fp, data, { print = true } = {}) {
 }
 export async function flist(fpd, options = {}) {
     const { filter, deep = false, absolute = false, print = true, stats = false } = options;
-    assert(path.isAbsolute(fpd), t("flist: 参数 fpd: '{{fpd}}' 必须是绝对路径", { fpd }));
-    assert(fpd.isdir, t("flist: 参数 fpd: '{{fpd}}' 必须以 / 结尾", { fpd }));
+    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)
@@ -179,13 +179,13 @@ export async function flist(fpd, options = {}) {
         return fps;
 }
 export async function fstat(fp) {
-    assert(path.isAbsolute(fp), t("fstat: 参数 fp: '{{fp}}' 必须是绝对路径", { fp }));
+    check(path.isAbsolute(fp), t("fstat: 参数 fp: '{{fp}}' 必须是绝对路径", { fp }));
     let stat = await fsp.stat(fp, { bigint: true });
     stat.fp = fp;
     return stat;
 }
 export async function flstat(fp) {
-    assert(path.isAbsolute(fp), t("flstat: 参数 fp: '{{fp}}' 必须是绝对路径", { fp }));
+    check(path.isAbsolute(fp), t("flstat: 参数 fp: '{{fp}}' 必须是绝对路径", { fp }));
     let stat = await fsp.lstat(fp, { bigint: true });
     stat.fp = fp;
     return stat;
@@ -205,8 +205,8 @@ export async function ffstat(handle) {
     - options?:
         - print?: `true` */
 export async function fdelete(fp, { print = true } = {}) {
-    assert(fp.length >= 6, `fp: ${fp} ${t('不能太短，防止误删文件')}`);
-    assert(path.isAbsolute(fp), t('fp 必须是绝对路径'));
+    check(fp.length >= 6, `fp: ${fp} ${t('不能太短，防止误删文件')}`);
+    check(path.isAbsolute(fp), t('fp 必须是绝对路径'));
     const { isdir } = fp;
     try {
         await fsp.rm(fp, { recursive: true });
@@ -248,8 +248,8 @@ export async function fdclear(fpd, { print = true } = {}) {
     fcopy('D:/temp/camera/', 'D:/camera/') */
 export async function fcopy(fp_src, fp_dst, { print = true, overwrite = true, filter, } = {}) {
     const { isdir } = fp_src;
-    assert(isdir === fp_dst.isdir, t('fp_src 和 fp_dst 必须同为文件路径或文件夹路径'));
-    assert(path.isAbsolute(fp_src) && path.isAbsolute(fp_dst), t('fp_src 和 fp_dst 必须为完整路径'));
+    check(isdir === fp_dst.isdir, t('fp_src 和 fp_dst 必须同为文件路径或文件夹路径'));
+    check(path.isAbsolute(fp_src) && path.isAbsolute(fp_dst), t('fp_src 和 fp_dst 必须为完整路径'));
     if (!isdir && filter)
         throw new Error(t('filter 选项只适用于 fp_src 为文件夹'));
     if (print)
@@ -297,8 +297,8 @@ export async function fcopy(fp_src, fp_dst, { print = true, overwrite = true, fi
     @example
     fmove('D:/temp/camera/', 'D:/camera/') */
 export async function fmove(fp_src, fp_dst, { overwrite = false, print = true } = {}) {
-    assert(fp_src.isdir === fp_dst.isdir, t('fp_src 和 fp_dst 必须同为文件路径或文件夹路径'));
-    assert(path.isAbsolute(fp_src) && path.isAbsolute(fp_dst), t('fp_src 和 fp_dst 必须为完整路径'));
+    check(fp_src.isdir === fp_dst.isdir, t('fp_src 和 fp_dst 必须同为文件路径或文件夹路径'));
+    check(path.isAbsolute(fp_src) && path.isAbsolute(fp_dst), t('fp_src 和 fp_dst 必须为完整路径'));
     if (print)
         console.log(t('移动'), fp_src, '->', fp_dst);
     if (!overwrite && fexists(fp_dst, { print: false }))
@@ -330,11 +330,11 @@ export async function fmove(fp_src, fp_dst, { overwrite = false, print = true }
         - overwrite?: `true`  默认覆盖（不检查效率更高）  better performance without check */
 export async function frename(fp, fp_, { fpd, print = true, overwrite = true } = {}) {
     if (fpd) {
-        assert(fpd.isdir);
+        check(fpd.isdir);
         fp = fpd + fp;
         fp_ = fpd + fp_;
     }
-    assert(path.isAbsolute(fp) && path.isAbsolute(fp_), t('fp 和 fp_ 必须是绝对路径'));
+    check(path.isAbsolute(fp) && path.isAbsolute(fp_), t('fp 和 fp_ 必须是绝对路径'));
     if (print)
         console.log(t('重命名'), fp, '->', fp_);
     if (!overwrite && fexists(fp_, { print: false }))
@@ -350,8 +350,8 @@ export async function frename(fp, fp_, { fpd, print = true, overwrite = true } =
         - print?: `true`
         - mode?: `'0o777'` */
 export async function fmkdir(fpd, { print = true, mode, } = {}) {
-    assert(path.isAbsolute(fpd), t('fpd 必须是绝对路径: ') + fpd);
-    assert(fpd.isdir, t('fpd 必须以 / 结尾: ') + fpd);
+    check(path.isAbsolute(fpd), t('fpd 必须是绝对路径: ') + fpd);
+    check(fpd.isdir, t('fpd 必须以 / 结尾: ') + fpd);
     // 类似 D:/ 这样的根路径，调用 fsp.mkdir 会报错无权限
     if (fpd.length === 3 &&
         'A' <= fpd[0] && fpd[0] <= 'Z' && fpd[1] === ':' && fpd[2] === '/')
@@ -376,10 +376,10 @@ export async function fmkdir(fpd, { print = true, mode, } = {}) {
     - fp_real: 现在真实文件/文件夹的路径
     - fp_link: 目标链接文件/文件夹的路径 */
 export async function flink(fp_real, fp_link, { junction = false, print = true, skip_existing = false } = {}) {
-    assert(path.isAbsolute(fp_real) && path.isAbsolute(fp_link), 'fp 必须是绝对路径');
+    check(path.isAbsolute(fp_real) && path.isAbsolute(fp_link), 'fp 必须是绝对路径');
     const is_fpd_real = fp_real.isdir;
     const is_fpd_link = fp_link.isdir;
-    assert(is_fpd_real === is_fpd_link, 'fp_real 和 fp_link 必须同为文件路径或文件夹路径');
+    check(is_fpd_real === is_fpd_link, 'fp_real 和 fp_link 必须同为文件路径或文件夹路径');
     if (fexists(fp_link, { print: false }))
         if (!skip_existing)
             throw new Error(`存在同名${is_fpd_link ? '文件夹' : '文件'}: ${fp_link}，无法创建链接`);
@@ -434,7 +434,7 @@ async function _zip(data, fp_zip, { dirname, print = { files: true, info: true }
             .map(fp => ([dirname + fp, fpd_src + fp])));
     }
     else {
-        assert(!dirname, 'dirname 在传入 fpd_src 时才生效');
+        check(!dirname, 'dirname 在传入 fpd_src 时才生效');
         entries = data;
     }
     if (print.info)
@@ -463,8 +463,8 @@ async function _zip(data, fp_zip, { dirname, print = { files: true, info: true }
                 archive.append(Buffer.isBuffer(fdata) ? fdata : Buffer.from(fdata.buffer), { name: fp });
             }
             else {
-                assert(fp.isdir === fdata.isdir);
-                assert(path.isAbsolute(fdata));
+                check(fp.isdir === fdata.isdir);
+                check(path.isAbsolute(fdata));
                 if (print.files)
                     console.log(`压缩 ${fdata} -> ${fp}`);
                 if (fp.isdir)

package/net.browser.d.ts

@@ -90,12 +90,14 @@ export declare class WebSocketConnectionError extends Error {
         - on_error?: 在 websocket 出错和非正常关闭 (close, error 事件) 时都调用，可以根据 error.type 来区分，error 的类型是 WebSocketConnectionError，
             type 为 'close' 时有 code 和 reason 属性
         - on_close?: 和 websocket 的 'close' 事件不相同，只在正常关闭 (close code 为 1000) 时才调用，否则都会调用 on_error
-            https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes  */
-export declare function connect_websocket(url: string | URL, { protocols, on_message, on_error, on_close, }: {
+            https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes
+        - print?: 是否打印连接、关闭信息 */
+export declare function connect_websocket(url: string | URL, { protocols, on_message, on_error, on_close, print }: {
     protocols?: string[];
     on_message(data: ArrayBuffer | string, websocket: WebSocket): any;
     on_error?(error: WebSocketConnectionError, websocket: WebSocket): any;
     on_close?(event: CloseEvent, websocket: WebSocket): any;
+    print?: boolean;
 }): Promise<WebSocket>;
 /** 接收到消息后的处理函数
     返回值可以是:
@@ -185,8 +187,10 @@ export declare class Remote {
         一元 rpc 接收方不需要设置 handlers, 发送方需要 */
     handlers: Map<number, MessageHandler<any[]>>;
     keeper?: RemoteKeeperOptions;
-    /** `false` 打印所有交互的 rpc messages */
+    /** `true` 是否打印连接信息、错误信息 */
     print: boolean;
+    /** `false` 打印所有交互的 rpc messages */
+    verbose: boolean;
     first_error: boolean;
     keeping: boolean;
     reconnecting: boolean;
@@ -196,10 +200,11 @@ export declare class Remote {
     static pack({ id, func, data, done, error }: Message): Uint8Array;
     /** 作为 websocket 连接发起方，传入 url 或 websocket，定义远程 Remote
         作为 websocket 连接接收方，不传 url 和 websocket，定义本地 Remote */
-    constructor({ url, funcs, print, websocket, keeper, on_error, }?: {
+    constructor({ url, funcs, print, verbose, websocket, keeper, on_error, }?: {
         url?: string;
         funcs?: Remote['funcs'];
         print?: boolean;
+        verbose?: boolean;
         websocket?: WebSocket;
         keeper?: RemoteKeeperOptions;
         on_error?(error: WebSocketConnectionError, websocket?: WebSocket): void;

package/net.browser.js

@@ -1,6 +1,6 @@
 import { t } from './i18n/instance.js';
 import './prototype.browser.js'; // to_time_str()
-import { assert, concat, genid, delay, Lock, encode, decode, timeout } from './utils.browser.js';
+import { assert, concat, genid, delay, Lock, encode, decode, timeout, check } from './utils.browser.js';
 const drop_request_headers = new Set([
     // : 开头的 key
     // sec-*
@@ -186,26 +186,29 @@ export class WebSocketConnectionError extends Error {
         - on_error?: 在 websocket 出错和非正常关闭 (close, error 事件) 时都调用，可以根据 error.type 来区分，error 的类型是 WebSocketConnectionError，
             type 为 'close' 时有 code 和 reason 属性
         - on_close?: 和 websocket 的 'close' 事件不相同，只在正常关闭 (close code 为 1000) 时才调用，否则都会调用 on_error
-            https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes  */
-export async function connect_websocket(url, { protocols, on_message, on_error, on_close, }) {
+            https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes
+        - print?: 是否打印连接、关闭信息 */
+export async function connect_websocket(url, { protocols, on_message, on_error, on_close, print = true }) {
     let websocket = new WebSocket(url, protocols);
     // https://stackoverflow.com/questions/11821096/what-is-the-difference-between-an-arraybuffer-and-a-blob/39951543
     websocket.binaryType = 'arraybuffer';
     return new Promise((resolve, reject) => {
         let settled = false;
         websocket.addEventListener('open', event => {
-            console.log(websocket.url +
-                (websocket.protocol ? ' ' + websocket.protocol.bracket() : '') +
-                t(' 已连接'));
+            if (print)
+                console.log(websocket.url +
+                    (websocket.protocol ? ' ' + websocket.protocol.bracket() : '') +
+                    t(' 已连接'));
             settled = true;
             resolve(websocket);
         });
         websocket.addEventListener('close', event => {
-            if (event.code === 1000) // 正常关闭
+            if (event.code === 1000) { // 正常关闭
                 if (on_close)
                     on_close(event, websocket);
-                else
+                else if (print)
                     console.log(`${websocket.url} ${t('已正常关闭')}`);
+            }
             else { // 异常关闭，认为发生了错误，进行错误处理
                 const error = new WebSocketConnectionError(websocket.url, protocols, event, `${t('连接被关闭')}, code: ${event.code}${event.reason ? `, ${t('原因')}: ${event.reason}` : ''}`);
                 if (settled)
@@ -278,8 +281,10 @@ export class Remote {
         一元 rpc 接收方不需要设置 handlers, 发送方需要 */
     handlers = new Map();
     keeper;
+    /** `true` 是否打印连接信息、错误信息 */
+    print = true;
     /** `false` 打印所有交互的 rpc messages */
-    print = false;
+    verbose = false;
     first_error = true;
     keeping = false;
     reconnecting = false;
@@ -305,7 +310,6 @@ export class Remote {
         return message;
     }
     static pack({ id, func, data = [], done, error }) {
-        assert('length' in data, 'message.data 必须是数组');
         let data_ = new Array(data.length);
         let bins = [];
         let bufs = [];
@@ -335,12 +339,12 @@ export class Remote {
     }
     /** 作为 websocket 连接发起方，传入 url 或 websocket，定义远程 Remote
         作为 websocket 连接接收方，不传 url 和 websocket，定义本地 Remote */
-    constructor({ url, funcs, print, websocket, keeper, on_error, } = {}) {
-        assert(!(url && websocket), '构建 Remote 时 url 和 websocket 最多只能传一个');
+    constructor({ url, funcs, print, verbose, websocket, keeper, on_error, } = {}) {
+        check(!(url && websocket), '构建 Remote 时 url 和 websocket 最多只能传一个');
         this.initiator = Boolean(url || websocket);
         if (url)
             this.url = url;
-        assert(!funcs?.echo);
+        check(!funcs?.echo);
         this.funcs = this.initiator ? funcs : {
             ...funcs,
             echo({ data }) {
@@ -349,12 +353,14 @@ export class Remote {
         };
         if (print !== undefined)
             this.print = print;
+        if (verbose !== undefined)
+            this.verbose = verbose;
         if (on_error)
             this.on_error = on_error;
         if (this.initiator)
             this.lwebsocket = new Lock(websocket || null);
         if (keeper) {
-            assert(this.initiator && url);
+            check(this.initiator && url);
             this.keeper = {
                 reconnect_interval: 1000 * 5,
                 heartbeat_interval: 1000 * 60,
@@ -380,14 +386,13 @@ export class Remote {
                 this.reconnecting = false;
                 if (!this.disconnected)
                     try {
-                        await timeout(3000, async () => {
-                            await this.connect();
-                        });
+                        await timeout(3000, async () => { await this.connect(); }, undefined, this.print);
                         this.first_error = true;
                     }
                     catch (error) {
                         // 重连失败的错误这里需要简单打印下，_on_error 不会打印，这里也不继续往上抛了
-                        console.log(error.message);
+                        if (this.print)
+                            console.log(error.message);
                         // 重连由 this.connect 里面调用 this._on_error 处理
                     }
             })();
@@ -397,8 +402,10 @@ export class Remote {
     };
     /** 使用者自定义的在连接后出错时的处理 */
     on_error(error, websocket) {
-        if (this.keeper)
-            console.log(error.message);
+        if (this.keeper) {
+            if (this.print)
+                console.log(error.message);
+        }
         else
             throw error;
     }
@@ -424,7 +431,8 @@ export class Remote {
                         try {
                             this.lwebsocket.resource = await connect_websocket(this.url, {
                                 on_message: this._on_message,
-                                on_error: this._on_error
+                                on_error: this._on_error,
+                                print: this.print
                             });
                             reconnected = true;
                         }
@@ -446,12 +454,11 @@ export class Remote {
                                     break;
                                 if (!this.reconnecting)
                                     try {
-                                        await timeout(1000 * 2, async () => {
-                                            await this.call('echo', []);
-                                        });
+                                        await timeout(1000 * 2, async () => { await this.call('echo', []); }, undefined, this.print);
                                     }
                                     catch (error) {
-                                        console.log(error.message);
+                                        if (this.print)
+                                            console.log(error.message);
                                         this._on_error(error);
                                     }
                             }
@@ -474,8 +481,8 @@ export class Remote {
         作为 websocket 连接接收方，必传 websocket 参数
         发送或连接出错时自动清理 message.id 对应的 handler */
     async send(message, websocket) {
-        assert(!message.data || message.data.every(arg => arg !== undefined), `message.data 数组中不能有 undefined 的项, 因为 json 序列化后会变为 null. (func: ${message.func}, id: ${message.id})`);
-        if (this.print)
+        check(!message.data || message.data.every(arg => arg !== undefined), `message.data 数组中不能有 undefined 的项, 因为 json 序列化后会变为 null. (func: ${message.func}, id: ${message.id})`);
+        if (this.verbose)
             console.log('remote.send:', message);
         try {
             await this.connect(websocket);
@@ -496,7 +503,7 @@ export class Remote {
     async handle(data, websocket) {
         const message = Remote.parse(data);
         const { id, func, done } = message;
-        if (this.print)
+        if (this.verbose)
             console.log('remote.handle:', message);
         let handler;
         if (func)

package/net.d.ts

@@ -147,15 +147,17 @@ export declare class WebSocketConnectionError extends Error {
         - on_error?: 在 websocket 出错和非正常关闭 (close, error 事件) 时都调用，可以根据 error.type 来区分，error 的类型是 WebSocketConnectionError，
             type 为 'close' 时有 code 和 reason 属性
         - on_close?: 和 websocket 的 'close' 事件不相同，只在正常关闭 (close code 为 1000) 时才调用，否则都会调用 on_error
-            https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes  */
+            https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes
+        - print?: 是否打印连接、关闭信息 */
 export declare function connect_websocket(url: string | URL, { protocols, max_payload, // 8 GB
-on_message, on_error, on_close, proxy }: {
+on_message, on_error, on_close, proxy, print, }: {
     protocols?: string[];
     max_payload?: number;
     on_message(data: ArrayBuffer | string, websocket: WebSocket): any;
     on_error?(error: WebSocketConnectionError, websocket: WebSocket): any;
     on_close?(event: CloseEvent, websocket: WebSocket): any;
     proxy?: string;
+    print?: boolean;
 }): Promise<WebSocket>;
 /** 接收到消息后的处理函数
     返回值可以是:
@@ -245,8 +247,10 @@ export declare class Remote {
         一元 rpc 接收方不需要设置 handlers, 发送方需要 */
     handlers: Map<number, MessageHandler<any[]>>;
     keeper?: RemoteKeeperOptions;
-    /** `false` 打印所有交互的 rpc messages */
+    /** `true` 是否打印连接信息、错误信息 */
     print: boolean;
+    /** `false` 打印所有交互的 rpc messages */
+    verbose: boolean;
     first_error: boolean;
     keeping: boolean;
     reconnecting: boolean;
@@ -256,10 +260,11 @@ export declare class Remote {
     static pack({ id, func, data, done, error }: Message): Uint8Array;
     /** 作为 websocket 连接发起方，传入 url 或 websocket，定义远程 Remote
         作为 websocket 连接接收方，不传 url 和 websocket，定义本地 Remote */
-    constructor({ url, funcs, print, websocket, keeper, on_error, }?: {
+    constructor({ url, funcs, print, verbose, websocket, keeper, on_error, }?: {
         url?: string;
         funcs?: Remote['funcs'];
         print?: boolean;
+        verbose?: boolean;
         websocket?: WebSocket;
         keeper?: RemoteKeeperOptions;
         on_error?(error: WebSocketConnectionError, websocket?: WebSocket): void;

package/net.js

@@ -3,7 +3,7 @@ import { buffer as stream_to_buffer, text as stream_to_text } from 'stream/consu
 import { isReadable } from 'stream';
 import { t } from './i18n/instance.js';
 import './prototype.js';
-import { inspect, concat, assert, genid, delay, Lock, encode, decode, pipe_with_error, map_values, unique, timeout } from './utils.js';
+import { inspect, concat, assert, genid, delay, Lock, encode, decode, pipe_with_error, map_values, unique, timeout, check } from './utils.js';
 export const WebSocketConnecting = 0;
 export const WebSocketOpen = 1;
 export const WebSocketClosing = 2;
@@ -38,13 +38,17 @@ const drop_request_headers = new Set([
     'upgrade',
 ]);
 let proxy_agents = {};
-async function request_retry(url, options, timeout, retries = 0, count = 0) {
+async function request_retry(url, options, _timeout, retries = 0, count = 0) {
     let { default: undici, request: undici_request } = await import('undici');
     undici_request ??= undici.request;
     try {
-        if (timeout > 0)
-            options.signal = AbortSignal.timeout(timeout);
-        return await undici_request(url, options);
+        if (_timeout > 0) {
+            // 设置给 undici 设置 timeout, signal 不一定管用，还是得自己兜底
+            options.signal = AbortSignal.timeout(_timeout);
+            return await timeout(_timeout + 300 /* 为 undici 兜底 */, async () => undici.request(url, options));
+        }
+        else
+            return await undici.request(url, options);
     }
     catch (error) {
         if (error.name === 'TimeoutError')
@@ -52,7 +56,7 @@ async function request_retry(url, options, timeout, retries = 0, count = 0) {
                 const duration = 2 ** count;
                 console.log(`${t('等待 {{duration}} 秒后重试 request (已尝试 {{_count}} 次) …', { duration, _count: count + 1 }).yellow}  ${url.toString().blue.underline}`);
                 await delay(1000 * duration);
-                return request_retry(url, options, timeout, retries, count + 1);
+                return request_retry(url, options, _timeout, retries, count + 1);
             }
             else
                 throw Object.assign(new Error(`request 超时: ${url.toString()}`), { name: 'TimeoutError' });
@@ -127,11 +131,11 @@ export async function request(url, options = {}) {
         // todo: 强制手动处理重定向，来正确处理 cookie ?
         maxRedirections: redirect === 'follow' ? 5 : 0,
         // 下面这些 timeout 都不是总的时间，没法用
-        // headersTimeout: timeout - 1000,
+        headersTimeout: timeout,
         // 从收完 headers 开始算
-        // bodyTimeout: timeout - 1000,
+        bodyTimeout: timeout,
         // @ts-ignore 没有类型声明，实际可用
-        // connectTimeout: timeout - 1000,
+        connectTimeout: timeout,
         headers,
         // --- body
         body: (() => {
@@ -392,9 +396,10 @@ let websocket_proxy_agents = {};
         - on_error?: 在 websocket 出错和非正常关闭 (close, error 事件) 时都调用，可以根据 error.type 来区分，error 的类型是 WebSocketConnectionError，
             type 为 'close' 时有 code 和 reason 属性
         - on_close?: 和 websocket 的 'close' 事件不相同，只在正常关闭 (close code 为 1000) 时才调用，否则都会调用 on_error
-            https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes  */
+            https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes
+        - print?: 是否打印连接、关闭信息 */
 export async function connect_websocket(url, { protocols, max_payload = 2 ** 33, // 8 GB
-on_message, on_error, on_close, proxy }) {
+on_message, on_error, on_close, proxy, print = true, }) {
     const { WebSocket } = await import('ws');
     const { HttpsProxyAgent } = await import('https-proxy-agent');
     let websocket = new WebSocket(url, protocols, {
@@ -410,9 +415,10 @@ on_message, on_error, on_close, proxy }) {
     return new Promise((resolve, reject) => {
         let settled = false;
         websocket.addEventListener('open', event => {
-            console.log(websocket.url +
-                (websocket.protocol ? ' ' + websocket.protocol.bracket() : '') +
-                t(' 已连接'));
+            if (print)
+                console.log(websocket.url +
+                    (websocket.protocol ? ' ' + websocket.protocol.bracket() : '') +
+                    t(' 已连接'));
             settled = true;
             resolve(websocket);
         });
@@ -422,13 +428,14 @@ on_message, on_error, on_close, proxy }) {
             // 接着马上 close 事件也被调用，此时 settled，马上调用了 on_error 函数，弄乱了顺序
             // error 的错误信息比较多，而且通过 await 得到的栈也比较清晰，这里延后调用 on_close 和 on_error，放到微任务队列之后的 timers 队列中
             setTimeout(() => {
-                if (event.code === 1000) // 正常关闭
+                if (event.code === 1000) { // 正常关闭
                     if (on_close)
                         on_close(event, websocket);
-                    else
+                    else if (print)
                         console.log(`${websocket.url} ${t('已正常关闭')}`);
+                }
                 else { // 异常关闭，认为发生了错误，进行错误处理
-                    assert(settled, t('websocket close 事件时应该已经 settled'));
+                    // websocket close 事件时已经 settled
                     const error = new WebSocketConnectionError(websocket.url, protocols, event, `${t('连接被关闭')}, code: ${event.code}${event.reason ? `, ${t('原因')}: ${event.reason}` : ''}`);
                     if (on_error)
                         on_error(error, websocket);
@@ -492,8 +499,10 @@ export class Remote {
         一元 rpc 接收方不需要设置 handlers, 发送方需要 */
     handlers = new Map();
     keeper;
+    /** `true` 是否打印连接信息、错误信息 */
+    print = true;
     /** `false` 打印所有交互的 rpc messages */
-    print = false;
+    verbose = false;
     first_error = true;
     keeping = false;
     reconnecting = false;
@@ -519,7 +528,6 @@ export class Remote {
         return message;
     }
     static pack({ id, func, data = [], done, error }) {
-        assert('length' in data, 'message.data 必须是数组');
         let data_ = new Array(data.length);
         let bins = [];
         let bufs = [];
@@ -549,12 +557,12 @@ export class Remote {
     }
     /** 作为 websocket 连接发起方，传入 url 或 websocket，定义远程 Remote
         作为 websocket 连接接收方，不传 url 和 websocket，定义本地 Remote */
-    constructor({ url, funcs, print, websocket, keeper, on_error, } = {}) {
-        assert(!(url && websocket), '构建 Remote 时 url 和 websocket 最多只能传一个');
+    constructor({ url, funcs, print, verbose, websocket, keeper, on_error, } = {}) {
+        check(!(url && websocket), '构建 Remote 时 url 和 websocket 最多只能传一个');
         this.initiator = Boolean(url || websocket);
         if (url)
             this.url = url;
-        assert(!funcs?.echo);
+        check(!funcs?.echo);
         this.funcs = this.initiator ? funcs : {
             ...funcs,
             echo({ data }) {
@@ -563,12 +571,14 @@ export class Remote {
         };
         if (print !== undefined)
             this.print = print;
+        if (verbose !== undefined)
+            this.verbose = verbose;
         if (on_error)
             this.on_error = on_error;
         if (this.initiator)
             this.lwebsocket = new Lock(websocket || null);
         if (keeper) {
-            assert(this.initiator && url);
+            check(this.initiator && url);
             this.keeper = {
                 reconnect_interval: 1000 * 5,
                 heartbeat_interval: 1000 * 60,
@@ -594,14 +604,13 @@ export class Remote {
                 this.reconnecting = false;
                 if (!this.disconnected)
                     try {
-                        await timeout(3000, async () => {
-                            await this.connect();
-                        });
+                        await timeout(3000, async () => { await this.connect(); }, undefined, this.print);
                         this.first_error = true;
                     }
                     catch (error) {
                         // 重连失败的错误这里需要简单打印下，_on_error 不会打印，这里也不继续往上抛了
-                        console.log(error.message);
+                        if (this.print)
+                            console.log(error.message);
                         // 重连由 this.connect 里面调用 this._on_error 处理
                     }
             })();
@@ -611,8 +620,10 @@ export class Remote {
     };
     /** 使用者自定义的在连接后出错时的处理 */
     on_error(error, websocket) {
-        if (this.keeper)
-            console.log(error.message);
+        if (this.keeper) {
+            if (this.print)
+                console.log(error.message);
+        }
         else
             throw error;
     }
@@ -638,7 +649,8 @@ export class Remote {
                         try {
                             this.lwebsocket.resource = await connect_websocket(this.url, {
                                 on_message: this._on_message,
-                                on_error: this._on_error
+                                on_error: this._on_error,
+                                print: this.print
                             });
                             reconnected = true;
                         }
@@ -660,12 +672,11 @@ export class Remote {
                                     break;
                                 if (!this.reconnecting)
                                     try {
-                                        await timeout(1000 * 2, async () => {
-                                            await this.call('echo', []);
-                                        });
+                                        await timeout(1000 * 2, async () => { await this.call('echo', []); }, undefined, this.print);
                                     }
                                     catch (error) {
-                                        console.log(error.message);
+                                        if (this.print)
+                                            console.log(error.message);
                                         this._on_error(error);
                                     }
                             }
@@ -688,8 +699,8 @@ export class Remote {
         作为 websocket 连接接收方，必传 websocket 参数
         发送或连接出错时自动清理 message.id 对应的 handler */
     async send(message, websocket) {
-        assert(!message.data || message.data.every(arg => arg !== undefined), `message.data 数组中不能有 undefined 的项, 因为 json 序列化后会变为 null. (func: ${message.func}, id: ${message.id})`);
-        if (this.print)
+        check(!message.data || message.data.every(arg => arg !== undefined), `message.data 数组中不能有 undefined 的项, 因为 json 序列化后会变为 null. (func: ${message.func}, id: ${message.id})`);
+        if (this.verbose)
             console.log('remote.send:', message);
         try {
             await this.connect(websocket);
@@ -710,7 +721,7 @@ export class Remote {
     async handle(data, websocket) {
         const message = Remote.parse(data);
         const { id, func, done } = message;
-        if (this.print)
+        if (this.verbose)
             console.log('remote.handle:', message);
         let handler;
         if (func)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "xshell",
-    "version": "1.0.196",
+    "version": "1.0.199",
     "type": "module",
     "main": "./index.js",
     "bin": {
@@ -53,13 +53,13 @@
         "@babel/parser": "^7.26.2",
         "@babel/traverse": "^7.25.9",
         "@koa/cors": "^5.0.0",
-        "@stylistic/eslint-plugin": "^2.10.1",
+        "@stylistic/eslint-plugin": "^2.11.0",
         "@svgr/webpack": "^8.1.0",
         "@types/sass-loader": "^8.0.9",
         "@types/ws": "^8.5.13",
-        "@typescript-eslint/eslint-plugin": "^8.13.0",
-        "@typescript-eslint/parser": "^8.13.0",
-        "@typescript-eslint/utils": "^8.13.0",
+        "@typescript-eslint/eslint-plugin": "^8.15.0",
+        "@typescript-eslint/parser": "^8.15.0",
+        "@typescript-eslint/utils": "^8.15.0",
         "@xterm/addon-fit": "^0.10.0",
         "@xterm/addon-web-links": "^0.11.0",
         "@xterm/addon-webgl": "^0.18.0",
@@ -75,13 +75,13 @@
         "commander": "^12.1.0",
         "css-loader": "^7.1.2",
         "emoji-regex": "^10.4.0",
-        "eslint": "^9.14.0",
+        "eslint": "^9.15.0",
         "eslint-plugin-import": "^2.31.0",
         "eslint-plugin-react": "^7.37.2",
         "gulp-sort": "^2.0.0",
         "hash-string": "^1.0.0",
         "https-proxy-agent": "^7.0.5",
-        "i18next": "^23.16.4",
+        "i18next": "^23.16.8",
         "i18next-scanner": "^4.6.0",
         "koa": "^2.15.3",
         "koa-compress": "^5.1.1",
@@ -91,10 +91,10 @@
         "mime-types": "^2.1.35",
         "ora": "^8.1.1",
         "react": "^18.3.1",
-        "react-i18next": "^15.1.0",
+        "react-i18next": "^15.1.1",
         "react-object-model": "^1.2.17",
         "resolve-path": "^1.4.0",
-        "sass": "^1.80.6",
+        "sass": "^1.81.0",
         "sass-loader": "^16.0.3",
         "source-map-loader": "^5.0.0",
         "strip-ansi": "^7.1.0",
@@ -104,8 +104,8 @@
         "ts-loader": "^9.5.1",
         "tslib": "^2.8.1",
         "typescript": "^5.6.3",
-        "ua-parser-js": "^2.0.0-rc.1",
-        "undici": "^6.20.1",
+        "ua-parser-js": "^2.0.0-rc.3",
+        "undici": "^6.21.0",
         "vinyl": "^3.0.0",
         "vinyl-fs": "^4.0.0",
         "webpack": "^5.96.1",
@@ -126,7 +126,7 @@
         "@types/koa-compress": "^4.0.6",
         "@types/lodash": "^4.17.13",
         "@types/mime-types": "^2.1.4",
-        "@types/node": "^22.9.0",
+        "@types/node": "^22.9.1",
         "@types/react": "^18.3.12",
         "@types/through2": "^2.0.41",
         "@types/tough-cookie": "^4.0.5",

package/process.d.ts

@@ -82,6 +82,7 @@ export interface CallOptions extends StartOptions {
         stdout?: (chunk: string) => void;
         stderr?: (chunk: string) => void;
     };
+    on_child?: (child: ChildProcess) => void;
 }
 export interface CallResult<TOutput extends string | Buffer = string> {
     pid: number;
@@ -111,10 +112,12 @@ export interface CallError {
         - encoding?: `'utf-8'` 子进程输出编码, 设置为 binary 时返回 stdout, stderr 类型为 Buffer; 否则是 string
             child output encoding. When set to binary, return stdout, stderr is of type Buffer; otherwise it is string
         - print?: `true` print 选项，支持设置细项  print option (with details)
+        - printers?: 实时处理 stdout 和 stderr 的每个 chunk
         - stdio?: `'pipe'` 设置为 'ignore' 时忽略 stdio 处理  when 'ignore' then ignore stdio processing
         - input?: string, 启动子进程之后写入到子进程 stdin 中的内容，写完后关闭子进程 stdin (pty 不关闭)
         - detached?: `false` 是否断开和 child 的关系 (ignore stdio, unref)  whether to break the connection with child (ignore stdio, unref)
-        - throw_code?: `true` code 不为 0 时是否抛出异常  whether to throw Error when code is not 0 */
+        - throw_code?: `true` code 不为 0 时是否抛出异常  whether to throw Error when code is not 0
+        - on_child: 可以传入回调函数及时获取通过 start 创建的子进程，便于执行 kill、获得 pid 等操作 */
 export declare function call(exe: string, args?: string[]): Promise<CallResult<string>>;
 export declare function call(exe: string, args?: string[], options?: CallOptions & {
     encoding: 'binary';

package/process.js

@@ -116,7 +116,7 @@ export async function start_nodejs(js, args = [], options) {
     return start(exe_nodejs, [js, ...args], options);
 }
 export async function call(exe, args = [], options = {}) {
-    const { encoding = 'utf-8', throw_code = true, printers } = options;
+    const { encoding = 'utf-8', throw_code = true, printers, on_child } = options;
     let { stdio = 'pipe', print = true } = options;
     if (typeof print === 'boolean')
         print = {
@@ -138,6 +138,7 @@ export async function call(exe, args = [], options = {}) {
         ...options,
         print: false,
     });
+    on_child?.(child);
     // --- collect output
     let stdouts = [];
     let stderrs = [];

package/server.js

@@ -2,13 +2,13 @@ import { createServer as http_create_server, } from 'http';
 import { createSecureServer as http2_create_server } from 'http2';
 import { createSecureContext } from 'tls';
 import zlib from 'zlib';
-import { createReadStream } from 'fs';
+import fs from 'fs';
 import { buffer as stream_to_buffer } from 'stream/consumers';
 import util from 'util';
 // --- my libs
 import { t } from './i18n/instance.js';
 import { request as _request, Remote } from './net.js';
-import { inspect, output_width, assert, range_to_numbers, encode, filter_keys, filter_values, consume_stream } from './utils.js';
+import { inspect, output_width, check, range_to_numbers, encode, filter_keys, filter_values, consume_stream, assert } from './utils.js';
 import { flist, fread, fstat } from './file.js';
 // ------------ my server
 export class Server {
@@ -57,7 +57,7 @@ export class Server {
             this.http = http;
         if (http2)
             this.http2 = http2;
-        assert(this.http || this.http2, 'http 和 http2 至少启用一个');
+        check(this.http || this.http2, 'http 和 http2 至少启用一个');
         if (http_port !== undefined)
             this.http_port = http_port;
         if (http2_port !== undefined)
@@ -73,7 +73,7 @@ export class Server {
         else if (funcs)
             this.remote = new Remote({ funcs });
         if (stdio_subscribable !== undefined) {
-            assert(remote || funcs);
+            check(remote || funcs);
             this.stdio_subscribable = stdio_subscribable;
         }
     }
@@ -125,7 +125,7 @@ export class Server {
                 return [domain, { key, cert }];
             })));
             const default_ctx = lazy_secure_ctxs[this.default_hostnames.find(hostname => hostname in lazy_secure_ctxs)];
-            assert(default_ctx);
+            check(default_ctx);
             this.http2_server = http2_create_server({
                 SNICallback(servername, callback) {
                     let lazy_ctx = lazy_secure_ctxs[servername] ||
@@ -571,7 +571,7 @@ export class Server {
             - download?: `undefined` 在 response.headers 中加上 content-disposition: attachment 指示浏览器下载文件
             - assets_root?: 替换模板 xxx.template.html 中 {root} 占位符 */
     async fsend(ctx, fp, { root, absolute, download, assets_root, } = {}) {
-        assert(absolute || root?.isdir, t('fsend 必须传 absolute 选项或 root 文件夹'));
+        check(absolute || root?.isdir, t('fsend 必须传 absolute 选项或 root 文件夹'));
         const { request, request: { method } } = ctx;
         let { response } = ctx;
         if (!absolute) {
@@ -630,7 +630,7 @@ export class Server {
             return fp;
         }
         if (assets_root) {
-            assert(fp.endsWith('.html'), '传入 assets_root 参数时 fp 应该为 .html 文件');
+            check(fp.endsWith('.html'), '传入 assets_root 参数时 fp 应该为 .html 文件');
             response.body = (await fread(fp, { print: false }))
                 .replaceAll('{root}', assets_root);
             return fp;
@@ -651,17 +651,17 @@ export class Server {
                 response.status = 206;
                 response.set('content-length', String(chunksize));
                 response.set('content-range', `bytes ${start}-${end}/${stats.size}`);
-                response.body = createReadStream(fp, { start, end });
+                response.body = fs.createReadStream(fp, { start, end });
             }
             catch {
                 response.status = 416;
                 response.set('content-length', String(stats.size));
                 response.set('content-range', `bytes */${stats.size}`);
-                response.body = createReadStream(fp);
+                response.body = fs.createReadStream(fp);
             }
         else {
             response.set('content-length', String(stats.size));
-            response.body = createReadStream(fp);
+            response.body = fs.createReadStream(fp);
         }
         return fp;
     }

package/utils.browser.d.ts

@@ -28,8 +28,9 @@ export declare class TimeoutError extends Error {
 }
 /** 在指定的时间 (milliseconds) 内运行某个任务，超时之后
     - 如果传入了 on_timeout 参数: 调用 on_timeout，返回 null
-    - 如果没传入 on_timeout 参数: 抛出 TimeoutError */
-export declare function timeout<TReturn>(milliseconds: number, action: () => Promise<TReturn>, on_timeout?: () => void | Promise<void>): Promise<TReturn>;
+    - 如果没传入 on_timeout 参数: 抛出 TimeoutError
+    - print?: 打印已超时任务的错误 */
+export declare function timeout<TReturn>(milliseconds: number, action: () => Promise<TReturn>, on_timeout?: () => void | Promise<void>, print?: boolean): Promise<TReturn>;
 /** https://stackoverflow.com/questions/63297164/how-to-only-accept-arraybuffer-as-parameter */
 export type StrictArrayBuffer = ArrayBuffer & {
     buffer?: undefined;

package/utils.browser.js

@@ -80,8 +80,9 @@ export class TimeoutError extends Error {
 }
 /** 在指定的时间 (milliseconds) 内运行某个任务，超时之后
     - 如果传入了 on_timeout 参数: 调用 on_timeout，返回 null
-    - 如果没传入 on_timeout 参数: 抛出 TimeoutError */
-export async function timeout(milliseconds, action, on_timeout) {
+    - 如果没传入 on_timeout 参数: 抛出 TimeoutError
+    - print?: 打印已超时任务的错误 */
+export async function timeout(milliseconds, action, on_timeout, print = true) {
     const error = new TimeoutError();
     return new Promise((resolve, reject) => {
         let done = false;
@@ -112,8 +113,10 @@ export async function timeout(milliseconds, action, on_timeout) {
                 resolve(await action());
             }
             catch (error) {
-                if (rejected)
-                    console.log(`已超时任务的错误: ${error.message}`);
+                if (rejected) {
+                    if (print)
+                        console.log(`已超时任务的错误: ${error.message}`);
+                }
                 else {
                     rejected = true;
                     reject(error);

package/utils.d.ts

@@ -89,8 +89,9 @@ export declare class TimeoutError extends Error {
 }
 /** 在指定的时间 (milliseconds) 内运行某个任务，超时之后
     - 如果传入了 on_timeout 参数: 调用 on_timeout，返回 null
-    - 如果没传入 on_timeout 参数: 抛出 TimeoutError */
-export declare function timeout<TReturn>(milliseconds: number, action: () => Promise<TReturn>, on_timeout?: () => void | Promise<void>): Promise<TReturn>;
+    - 如果没传入 on_timeout 参数: 抛出 TimeoutError
+    - print?: 打印已超时任务的错误 */
+export declare function timeout<TReturn>(milliseconds: number, action: () => Promise<TReturn>, on_timeout?: () => void | Promise<void>, print?: boolean): Promise<TReturn>;
 /** https://stackoverflow.com/questions/63297164/how-to-only-accept-arraybuffer-as-parameter */
 export type StrictArrayBuffer = ArrayBuffer & {
     buffer?: undefined;

package/utils.js

@@ -251,8 +251,9 @@ export class TimeoutError extends Error {
 }
 /** 在指定的时间 (milliseconds) 内运行某个任务，超时之后
     - 如果传入了 on_timeout 参数: 调用 on_timeout，返回 null
-    - 如果没传入 on_timeout 参数: 抛出 TimeoutError */
-export async function timeout(milliseconds, action, on_timeout) {
+    - 如果没传入 on_timeout 参数: 抛出 TimeoutError
+    - print?: 打印已超时任务的错误 */
+export async function timeout(milliseconds, action, on_timeout, print = true) {
     const error = new TimeoutError();
     return new Promise((resolve, reject) => {
         let done = false;
@@ -283,8 +284,10 @@ export async function timeout(milliseconds, action, on_timeout) {
                 resolve(await action());
             }
             catch (error) {
-                if (rejected)
-                    console.log(`已超时任务的错误: ${error.message}`);
+                if (rejected) {
+                    if (print)
+                        console.log(`已超时任务的错误: ${error.message}`);
+                }
                 else {
                     rejected = true;
                     reject(error);

package/xlint.js

@@ -795,6 +795,8 @@ export const xlint_config = {
         // ------------ 括号
         // a => { } 而不是 (a) => { }
         '@stylistic/arrow-parens': ['error', 'as-needed', { requireForBlockBody: false }],
+        // arrow function 在 return 单条表达式时去掉后面的大括号, a => 1
+        'arrow-body-style': 'error',
         // 不要多余的大括号
         // if (true)
         //     console.log()