xshell 1.0.46 → 1.0.48

package/file.d.ts

@@ -155,6 +155,8 @@ export declare function flink(fp_real: string, fp_link: string, { junction, prin
     junction?: boolean;
     print?: boolean;
 }): Promise<void>;
-/** 打开一个文件并搜索替换某个 pattern  open a file and replace certain pattern */
-export declare function freplace(fp: string, pattern: string | RegExp, replacement: string): Promise<void>;
+/** 打开一个文件并搜索替换某个 pattern */
+export declare function freplace(fp: string, pattern: string | RegExp, replacement: string, { print }?: {
+    print?: boolean;
+}): Promise<void>;
 export {};

package/file.js

@@ -1,6 +1,5 @@
 import { promises as fsp, default as fs } from 'fs';
 import { isUint8Array } from 'util/types';
-import fse from 'fs-extra';
 import { path } from './path.js';
 import { t } from './i18n/instance.js';
 import { to_json } from './prototype.js';
@@ -209,7 +208,8 @@ export async function fcopy(fp_src, fp_dst, { print = true, overwrite = true, }
     assert(path.isAbsolute(fp_src) && path.isAbsolute(fp_dst), t('fp_src 和 fp_dst 必须为完整路径'));
     if (print)
         console.log(t('复制'), fp_src, '→', fp_dst);
-    await fse.copy(fp_src, fp_dst, { overwrite, errorOnExist: true });
+    const { copy } = await import('fs-extra');
+    await copy(fp_src, fp_dst, { overwrite, errorOnExist: true });
 }
 /** 移动文件或文件夹  move file or direcotry
     - src: 源 文件/文件夹 完整路径  src file/directory absolute path
@@ -223,7 +223,8 @@ export async function fmove(src, dst, { overwrite = false, print = true } = {})
         throw new Error(t('src 和 dst 必须为完整路径'));
     if (print)
         console.log(t('移动'), src, '→', dst);
-    await fse.move(src, dst, { overwrite });
+    const { move } = await import('fs-extra');
+    await move(src, dst, { overwrite });
 }
 /** 重命名文件  rename file
     - fp:  当前文件名／路径  current filename/path
@@ -293,9 +294,9 @@ export async function flink(fp_real, fp_link, { junction = false, print = true }
     else
         fsp.symlink(fp_real, fp_link, is_fpd_real ? 'dir' : 'file');
 }
-/** 打开一个文件并搜索替换某个 pattern  open a file and replace certain pattern */
-export async function freplace(fp, pattern, replacement) {
-    await fwrite(fp, (await fread(fp))
-        .replaceAll(pattern, replacement));
+/** 打开一个文件并搜索替换某个 pattern */
+export async function freplace(fp, pattern, replacement, { print = true } = {}) {
+    await fwrite(fp, (await fread(fp, { print }))
+        .replaceAll(pattern, replacement), { print });
 }
 //# sourceMappingURL=file.js.map

package/net.browser.d.ts

@@ -163,6 +163,7 @@ export declare class Remote {
     handlers: Map<number, MessageHandler>;
     /** `false` 打印所有交互的 rpc messages */
     print: boolean;
+    reconnecting: boolean;
     /** 使用 Uint8Array 作为参数更灵活 https://stackoverflow.com/a/74505197/7609214 */
     static parse<TData extends any[] = any[]>(buffer: Uint8Array): Message<TData>;
     static pack({ id, func, data, done, error }: Message): Uint8Array;
@@ -198,4 +199,17 @@ export declare class Remote {
         作为 websocket 连接发起方，不需要传入 websocket
         作为 websocket 连接接收方，必传 websocket 参数  */
     call<TReturn extends any[] = any[]>(func: string, args?: any[], websocket?: WebSocket): Promise<TReturn>;
+    /** 是幂等的，在未连接，或 (on_error) 检测到连接断开后以固定间隔尝试 remote.call(func) 重连
+        通常在 on_error 中和首次启动时调用
+        - func?: 连接后调用的函数，通常为某个 register 函数，将自身注册到 server
+        - duration?: `1000 * 30` 首次重连失败后的后续尝试间隔 (单位: ms)
+        - first_delay?: `0` 调用函数后是否立即连接，还是在 first_delay 后重连 (单位: ms)
+        - on_error?: 接收每次尝试连接的错误 */
+    start_reconnecting({ func, interval, first_delay, on_error, }?: RemoteReconnectingOptions): Promise<void>;
+}
+export interface RemoteReconnectingOptions {
+    func?: string;
+    interval?: number;
+    first_delay?: number;
+    on_error?(error: Error): void;
 }

package/net.browser.js

@@ -273,6 +273,7 @@ export class Remote {
     handlers = new Map();
     /** `false` 打印所有交互的 rpc messages */
     print = false;
+    reconnecting = false;
     /** 使用 Uint8Array 作为参数更灵活 https://stackoverflow.com/a/74505197/7609214 */
     static parse(buffer) {
         const dv = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
@@ -452,5 +453,38 @@ export class Remote {
             }
         });
     }
+    /** 是幂等的，在未连接，或 (on_error) 检测到连接断开后以固定间隔尝试 remote.call(func) 重连
+        通常在 on_error 中和首次启动时调用
+        - func?: 连接后调用的函数，通常为某个 register 函数，将自身注册到 server
+        - duration?: `1000 * 30` 首次重连失败后的后续尝试间隔 (单位: ms)
+        - first_delay?: `0` 调用函数后是否立即连接，还是在 first_delay 后重连 (单位: ms)
+        - on_error?: 接收每次尝试连接的错误 */
+    async start_reconnecting({ func, interval = 1000 * 10, first_delay = 0, on_error, } = {}) {
+        assert(this.url);
+        if (this.reconnecting)
+            return;
+        this.reconnecting = true;
+        if (first_delay)
+            await delay(first_delay);
+        for (;;) {
+            if (this.lwebsocket.resource?.readyState !== WebSocket.OPEN)
+                try {
+                    if (func)
+                        await this.call(func);
+                    else
+                        await this.connect();
+                    this.reconnecting = false;
+                    break;
+                }
+                catch (error) {
+                    on_error?.(error);
+                }
+            else {
+                this.reconnecting = false;
+                break;
+            }
+            await delay(interval);
+        }
+    }
 }
 //# sourceMappingURL=net.browser.js.map

package/net.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" resolution-mode="require"/>
-import { FormData, Headers, type Response, type RequestInit } from 'undici';
-import { WebSocket, type CloseEvent, type ErrorEvent } from 'ws';
-import { Cookie, CookieJar, MemoryCookieStore } from 'tough-cookie';
+import type { FormData, Headers, Response, RequestInit } from 'undici';
+import type { WebSocket, CloseEvent, ErrorEvent } from 'ws';
+import type { Cookie, CookieJar, MemoryCookieStore } from 'tough-cookie';
 declare module 'tough-cookie' {
     interface MemoryCookieStore {
         idx: Record<string, any>;
@@ -10,14 +10,19 @@ declare module 'tough-cookie' {
 import './prototype.js';
 import type { Encoding } from './file.js';
 import { inspect, Lock } from './utils.js';
+export type { WebSocket, Headers };
+export declare const WebSocketConnecting = 0;
+export declare const WebSocketOpen = 1;
+export declare const WebSocketClosing = 2;
+export declare const WebSocketClosed = 3;
 export declare enum MyProxy {
     socks5 = "http://localhost:10080",
     whistle = "http://localhost:8899"
 }
-export { Headers };
 export declare const cookies: {
     store: MemoryCookieStore;
     jar: CookieJar;
+    init(): Promise<void>;
     get(domain_or_url: string, str?: boolean): Cookie[] | Promise<Cookie[] | string>;
 };
 export { Cookie };
@@ -100,7 +105,6 @@ export declare function rpc(func: string, args?: any[], { url, async: _async, ig
     async?: boolean;
     ignore?: boolean;
 }): Promise<any>;
-export { WebSocket };
 export declare class WebSocketConnectionError extends Error {
     name: string;
     websocket: WebSocket;
@@ -211,6 +215,7 @@ export declare class Remote {
     handlers: Map<number, MessageHandler>;
     /** `false` 打印所有交互的 rpc messages */
     print: boolean;
+    reconnecting: boolean;
     /** 使用 Uint8Array 作为参数更灵活 https://stackoverflow.com/a/74505197/7609214 */
     static parse<TData extends any[] = any[]>(buffer: Uint8Array): Message<TData>;
     static pack({ id, func, data, done, error }: Message): Uint8Array;
@@ -246,9 +251,28 @@ export declare class Remote {
         作为 websocket 连接发起方，不需要传入 websocket
         作为 websocket 连接接收方，必传 websocket 参数  */
     call<TReturn extends any[] = any[]>(func: string, args?: any[], websocket?: WebSocket): Promise<TReturn>;
+    /** 是幂等的，在未连接，或 (on_error) 检测到连接断开后以固定间隔尝试 remote.call(func) 重连
+        通常在 on_error 中和首次启动时调用
+        - func?: 连接后调用的函数，通常为某个 register 函数，将自身注册到 server
+        - duration?: `1000 * 30` 首次重连失败后的后续尝试间隔 (单位: ms)
+        - first_delay?: `0` 调用函数后是否立即连接，还是在 first_delay 后重连 (单位: ms)
+        - on_error?: 接收每次尝试连接的错误 */
+    start_reconnecting({ func, interval, first_delay, on_error, }?: RemoteReconnectingOptions): Promise<void>;
 }
-/** 通常将连接到 server 的 client 抽象为下面的结构 */
-export interface RemoteClient {
+/** 为连接到 server 的 client 创建 RemoteClient，以便后续调用 client 中方法 */
+export declare class RemoteClient {
     remote: Remote;
     websocket: WebSocket;
+    constructor(remote: Remote, websocket: WebSocket);
+    /** 调用 client 中的 func, 只适用于最简单的一元 rpc (请求, 响应) */
+    call<TReturn extends any[] = any[]>(func: string, args?: any[]): Promise<TReturn>;
+    /** 发送 message 到 client
+        发送或连接出错时自动清理 message.id 对应的 handler */
+    send(message: Message): Promise<void>;
+}
+export interface RemoteReconnectingOptions {
+    func?: string;
+    interval?: number;
+    first_delay?: number;
+    on_error?(error: Error): void;
 }

package/net.js

@@ -1,21 +1,25 @@
-import { fetch, ProxyAgent, FormData, Headers } from 'undici';
-import { WebSocket } from 'ws';
-import { Cookie, CookieJar, MemoryCookieStore } from 'tough-cookie';
-import make_fetch_cookie from 'fetch-cookie';
 import { t } from './i18n/instance.js';
 import './prototype.js';
 import { inspect, concat, assert, genid, delay, Lock } from './utils.js';
+export const WebSocketConnecting = 0;
+export const WebSocketOpen = 1;
+export const WebSocketClosing = 2;
+export const WebSocketClosed = 3;
 export var MyProxy;
 (function (MyProxy) {
     MyProxy["socks5"] = "http://localhost:10080";
     MyProxy["whistle"] = "http://localhost:8899";
 })(MyProxy || (MyProxy = {}));
-export { Headers };
 // ------------------------------------ fetch, request
-let cookie_store = new MemoryCookieStore();
 export const cookies = {
-    store: cookie_store,
-    jar: new CookieJar(cookie_store),
+    store: null,
+    jar: null,
+    async init() {
+        if (this.jar)
+            return;
+        const { MemoryCookieStore, CookieJar } = await import('tough-cookie');
+        this.jar = new CookieJar(this.store = new MemoryCookieStore());
+    },
     get(domain_or_url, str = false) {
         if (domain_or_url.startsWith('http'))
             if (str)
@@ -31,7 +35,6 @@ export const cookies = {
         return cookies;
     },
 };
-export { Cookie };
 /** 对于 request() 函数来说无意义的 headers，会自动过滤掉 */
 const drop_request_headers = new Set([
     // : 开头的 key
@@ -45,8 +48,12 @@ const drop_request_headers = new Set([
     'upgrade',
 ]);
 let proxy_agents = {};
-const fetch_cookie = make_fetch_cookie(fetch, cookies.jar, false);
+let fetch_cookie;
 async function fetch_retry(url, options, timeout, retries = 0, count = 0) {
+    const { fetch } = await import('undici');
+    const { default: make_fetch_cookie } = await import('fetch-cookie');
+    await cookies.init();
+    fetch_cookie ||= make_fetch_cookie(fetch, cookies.jar, false);
     try {
         options.signal = AbortSignal.timeout(timeout);
         return await fetch_cookie(url, options);
@@ -64,6 +71,7 @@ async function fetch_retry(url, options, timeout, retries = 0, count = 0) {
     }
 }
 export async function request(url, { method, queries, headers: _headers, body, type = 'application/json', proxy, encoding, retries, timeout = 5 * 1000, auth, cookies: _cookies, raw = false, } = {}) {
+    const { Headers, ProxyAgent, FormData } = await import('undici');
     url = new URL(url);
     if (queries)
         for (const key in queries) {
@@ -278,7 +286,6 @@ export async function rpc(func, args, { url = 'http://localhost:8421/api/rpc', a
 }
 let decoder = new TextDecoder();
 let encoder = new TextEncoder();
-export { WebSocket };
 export class WebSocketConnectionError extends Error {
     name = 'WebSocketConnectionError';
     websocket;
@@ -331,6 +338,7 @@ export class WebSocketConnectionError extends Error {
             https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes  */
 export async function connect_websocket(url, { protocols, max_payload = 2 ** 33, // 8 GB
 on_message, on_error, on_close }) {
+    const { WebSocket } = await import('ws');
     let websocket = new WebSocket(url, protocols, {
         maxPayload: max_payload,
         skipUTF8Validation: true
@@ -426,6 +434,7 @@ export class Remote {
     handlers = new Map();
     /** `false` 打印所有交互的 rpc messages */
     print = false;
+    reconnecting = false;
     /** 使用 Uint8Array 作为参数更灵活 https://stackoverflow.com/a/74505197/7609214 */
     static parse(buffer) {
         const dv = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
@@ -500,7 +509,7 @@ export class Remote {
         作为 websocket 连接接收方，需要传入使用的 websocket 连接，确保这个这个连接的状态 */
     async connect(websocket) {
         if (this.initiator)
-            if (this.lwebsocket.resource?.readyState === WebSocket.OPEN)
+            if (this.lwebsocket.resource?.readyState === WebSocketOpen)
                 return;
             else if (!this.url)
                 throw new Error(t('创建 Remote 时传入的 websocket 连接已断开'));
@@ -510,7 +519,7 @@ export class Remote {
                 return this.lwebsocket.request(async (websocket) => {
                     // 保存的 rpc 状态在 this.handlers, 与 websocket 无关，因此即使断开重连也不影响 rpc 的运行，即
                     // 底层连接断开后自动重连对上层应该是无感知的，除非再次连接时失败
-                    if (websocket?.readyState === WebSocket.OPEN)
+                    if (websocket?.readyState === WebSocketOpen)
                         return;
                     else // 重连
                         this.lwebsocket.resource = await connect_websocket(this.url, {
@@ -520,7 +529,7 @@ export class Remote {
                             on_error: this.on_error.bind(this)
                         });
                 });
-        else if (websocket.readyState !== WebSocket.OPEN)
+        else if (websocket.readyState !== WebSocketOpen)
             throw new Error(t('传入的 websocket 连接已断开'));
     }
     /** 作为 websocket 连接发起方手动关闭到对端的 websocket 连接 */
@@ -576,7 +585,7 @@ export class Remote {
         }
         catch (error) {
             // handler 出错并不意味着 rpc 一定会结束，可能 error 是运行中的正常数据，所以不能清理 handler
-            if (websocket.readyState === WebSocket.OPEN &&
+            if (websocket.readyState === WebSocketOpen &&
                 !message.error // 防止无限循环往对方发送 error, 只有在对方无错误时才可以发送
             )
                 await this.send({ id, error, /* 不能设置 done 清理对面 handler, 理由同上 */ }, websocket);
@@ -605,5 +614,56 @@ export class Remote {
             }
         });
     }
+    /** 是幂等的，在未连接，或 (on_error) 检测到连接断开后以固定间隔尝试 remote.call(func) 重连
+        通常在 on_error 中和首次启动时调用
+        - func?: 连接后调用的函数，通常为某个 register 函数，将自身注册到 server
+        - duration?: `1000 * 30` 首次重连失败后的后续尝试间隔 (单位: ms)
+        - first_delay?: `0` 调用函数后是否立即连接，还是在 first_delay 后重连 (单位: ms)
+        - on_error?: 接收每次尝试连接的错误 */
+    async start_reconnecting({ func, interval = 1000 * 10, first_delay = 0, on_error, } = {}) {
+        assert(this.url);
+        if (this.reconnecting)
+            return;
+        this.reconnecting = true;
+        if (first_delay)
+            await delay(first_delay);
+        for (;;) {
+            if (this.lwebsocket.resource?.readyState !== WebSocketOpen)
+                try {
+                    if (func)
+                        await this.call(func);
+                    else
+                        await this.connect();
+                    this.reconnecting = false;
+                    break;
+                }
+                catch (error) {
+                    on_error?.(error);
+                }
+            else {
+                this.reconnecting = false;
+                break;
+            }
+            await delay(interval);
+        }
+    }
+}
+/** 为连接到 server 的 client 创建 RemoteClient，以便后续调用 client 中方法 */
+export class RemoteClient {
+    remote;
+    websocket;
+    constructor(remote, websocket) {
+        this.remote = remote;
+        this.websocket = websocket;
+    }
+    /** 调用 client 中的 func, 只适用于最简单的一元 rpc (请求, 响应) */
+    async call(func, args) {
+        return this.remote.call(func, args, this.websocket);
+    }
+    /** 发送 message 到 client
+        发送或连接出错时自动清理 message.id 对应的 handler */
+    async send(message) {
+        return this.remote.send(message, this.websocket);
+    }
 }
 //# sourceMappingURL=net.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xshell",
-  "version": "1.0.46",
+  "version": "1.0.48",
   "type": "module",
   "main": "./index.js",
   "bin": {
@@ -62,7 +62,7 @@
     "fs-extra": "^11.1.1",
     "gulp-sort": "^2.0.0",
     "hash-string": "^1.0.0",
-    "i18next": "^23.4.2",
+    "i18next": "^23.4.4",
     "i18next-scanner": "^4.3.0",
     "js-cookie": "^3.0.5",
     "koa": "^2.14.2",
@@ -72,9 +72,8 @@
     "map-stream": "0.0.7",
     "mime-types": "^2.1.35",
     "ora": "^7.0.1",
-    "qs": "^6.11.2",
     "react": "^18.2.0",
-    "react-i18next": "^13.0.3",
+    "react-i18next": "^13.1.1",
     "resolve-path": "^1.4.0",
     "strip-ansi": "^7.1.0",
     "through2": "^4.0.2",
@@ -96,11 +95,10 @@
     "@types/js-cookie": "^3.0.3",
     "@types/koa": "^2.13.8",
     "@types/koa-compress": "^4.0.3",
-    "@types/lodash": "^4.14.196",
+    "@types/lodash": "^4.14.197",
     "@types/mime-types": "^2.1.1",
-    "@types/node": "^20.4.8",
-    "@types/qs": "^6.9.7",
-    "@types/react": "^18.2.18",
+    "@types/node": "^20.4.9",
+    "@types/react": "^18.2.20",
     "@types/through2": "^2.0.38",
     "@types/tough-cookie": "^4.0.2",
     "@types/vinyl-fs": "^3.0.2",

package/repl.d.ts

@@ -1,5 +1,3 @@
-import ts from 'typescript';
-import type { Statement } from 'typescript';
 import type { Context } from 'koa';
 import './prototype.js';
 declare global {
@@ -9,23 +7,6 @@ declare global {
 }
 /** 谨慎使用，webpack 打包后可能会变成 /d:/1/mod/node_modules/xshell/ 这样的编译期路径 */
 export declare const fpd_root: string;
-export declare function set_inspection_limit(limit?: number): void;
-export declare function set_printing_compiled_js(enabled: boolean): void;
-export declare function parse_code(code: string): ts.SourceFile;
-export declare function generate_code(stmts: Statement[]): string;
-export declare function compile_ts({ fp, code, print, save, }?: {
-    fp?: string;
-    code?: string;
-    print?: boolean;
-    save?: boolean;
-}): Promise<string>;
-/** tsconfig.compilerOptions */
-export declare let ts_options: any;
-export declare let ts_options_commonjs: any;
-export declare let ts_options_commonjs_repl: any;
-export declare function load_tsconfig(): Promise<void>;
-export declare function eval_ts(code: string): Promise<any>;
-export declare function repl_ts(code: string): Promise<any>;
 export declare function start_repl(): Promise<void>;
 export declare function stop(): Promise<void>;
 export declare function exit(): Promise<void>;

package/repl.js

@@ -1,255 +1,15 @@
-import nvm from 'vm';
 import repl from 'repl';
 import process from 'process';
 import { fileURLToPath } from 'url';
-import ts from 'typescript';
-const { factory, createPrinter, SyntaxKind, NodeFlags, ModifierFlags, isIdentifier, isNamedImports, isImportDeclaration, isAwaitExpression, isExpressionStatement, isVariableStatement, isNamespaceImport, isClassDeclaration, isCallExpression, isReturnStatement, isBinaryExpression, isFunctionDeclaration, } = ts;
 import { path } from './path.js';
 import { t } from './i18n/instance.js';
 import './prototype.js';
-import { log_line, delay, inspect, set_inspect_options, Timer, delta2str } from './utils.js';
-import { fread, fwrite } from './file.js';
+import { delay, set_inspect_options, delta2str } from './utils.js';
 import { Remote } from './net.js';
 set_inspect_options();
 let server;
-let inspection_limit = 10000;
-let printing_compiled_js = false;
 /** 谨慎使用，webpack 打包后可能会变成 /d:/1/mod/node_modules/xshell/ 这样的编译期路径 */
 export const fpd_root = path.dirname(fileURLToPath(import.meta.url)) + '/';
-export function set_inspection_limit(limit = 10000) {
-    if (limit === -1)
-        limit = 50 * 10 ** 4;
-    inspection_limit = limit;
-}
-export function set_printing_compiled_js(enabled) {
-    printing_compiled_js = enabled;
-}
-// ------------------------------------ Code Compilers, Transformers
-function resolve_kind(kind) {
-    return kind === SyntaxKind.VariableStatement ? 'VariableStatement' : SyntaxKind[kind];
-}
-function print_ast(nodes, sourceFile) {
-    function print_node(node) {
-        console.log(`${resolve_kind(node.kind)}: ${node.getText(sourceFile)}`);
-    }
-    if (Array.isArray(nodes))
-        nodes.forEach(node => { print_node(node); });
-    else
-        print_node(nodes);
-}
-export function parse_code(code) {
-    return ts.createSourceFile('repl.ts', code, ts.ScriptTarget.ESNext);
-}
-export function generate_code(stmts) {
-    return createPrinter({ omitTrailingSemicolon: true, removeComments: false, newLine: ts.NewLineKind.LineFeed })
-        .printFile(factory.updateSourceFile(ts.createSourceFile('output.ts', '', ts.ScriptTarget.ESNext), stmts));
-}
-function trans_import_2_require(import_decl) {
-    if (!isImportDeclaration(import_decl))
-        return import_decl;
-    const { importClause: import_clause, moduleSpecifier: module_specifier } = import_decl;
-    // require('module_specifier')
-    const require_module_stmt = factory.createCallExpression(factory.createIdentifier('require'), [], [module_specifier]);
-    // aaa, bbb as ccc, default as ddd, ...
-    // (import_clause.namedBindings as NamedImports).elements
-    return [
-        // import mod from 'mod'
-        // globalThis.mod = __importDefault(require("mod")).default
-        ...import_clause.name ? [
-            factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression(factory.createIdentifier('globalThis'), import_clause.name), factory.createPropertyAccessExpression(factory.createCallExpression(factory.createIdentifier('__importDefault'), [], [require_module_stmt]), 'default')))
-        ] : [],
-        // import * as mod from 'mod'
-        // globalThis.mod = __importStar(require("mod"))
-        ...import_clause.namedBindings && isNamespaceImport(import_clause.namedBindings) ? [
-            factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression(factory.createIdentifier('globalThis'), import_clause.namedBindings.name), factory.createCallExpression(factory.createIdentifier('__importStar'), [], [require_module_stmt])))
-        ] : [],
-        // import { element2 as element2_, element3 as element3_, other, default as mod2 } from 'mod2'
-        ...import_clause.namedBindings && isNamedImports(import_clause.namedBindings) ? [
-            // var { element2: element2_, element3 } = __importDefault(require("mod"))
-            factory.createVariableStatement([], [factory.createVariableDeclaration(factory.createObjectBindingPattern(
-                // ImportSpecifier[] -> ObjectBindingPattern.BindingElement[]
-                import_clause.namedBindings.elements.map(import_specifier => factory.createBindingElement(undefined, import_specifier.propertyName, import_specifier.name, import_specifier.propertyName?.text === 'default' ? require_module_stmt : undefined))), undefined, undefined, require_module_stmt)]),
-            // Object.assign(globalThis, { element2_, element3 })
-            factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('Object'), 'assign'), [], 
-            // ImportSpecifier[] -> ObjectBindingPattern.BindingElement[]
-            [factory.createIdentifier('globalThis'), factory.createObjectLiteralExpression(import_clause.namedBindings.elements.map(import_specifier => factory.createShorthandPropertyAssignment(import_specifier.name)), false)])),
-            factory.createExpressionStatement(import_clause.namedBindings.elements.length === 1 ?
-                // (a)
-                factory.createParenthesizedExpression(import_clause.namedBindings.elements[0].name)
-                : // ({ a: xxx, b: xxx })
-                    factory.createObjectLiteralExpression(import_clause.namedBindings.elements.map(import_specifier => factory.createShorthandPropertyAssignment(import_specifier.name)), false))
-        ] : [],
-    ];
-}
-/** export function foo () { } */
-function trans_export_stmt(stmt) {
-    if (ts.isExportAssignment(stmt))
-        return factory.createExpressionStatement(stmt.expression);
-    function is_export_modifier(modifier) {
-        return modifier.flags & ModifierFlags.Export || modifier.flags & ModifierFlags.ExportDefault || modifier.kind === SyntaxKind.ExportKeyword;
-    }
-    // @ts-ignore
-    if (stmt.modifiers?.some(modifier => is_export_modifier(modifier))) {
-        // @ts-ignore
-        stmt.modifiers = factory.createNodeArray(
-        // @ts-ignore
-        stmt.modifiers.filter(modifier => !is_export_modifier(modifier)));
-        return stmt;
-    }
-    return stmt;
-}
-/** const a = 123, b = 234, { c, d: e } = obj */
-function trans_variable_decl_2_var(var_decl) {
-    if (!isVariableStatement(var_decl))
-        return var_decl;
-    // @ts-ignore
-    var_decl.declarationList.flags = NodeFlags.None;
-    return var_decl;
-}
-function trans_class_decl_2_expr(class_decl) {
-    if (!isClassDeclaration(class_decl))
-        return class_decl;
-    // export class C { } 这样的语句已经在 trans_export_stmt 中被去掉了 export modifier
-    return factory.createVariableStatement([], factory.createVariableDeclarationList([
-        factory.createVariableDeclaration(class_decl.name, undefined, undefined, factory.createClassExpression(undefined, class_decl.name, undefined, class_decl.heritageClauses, class_decl.members))
-    ]));
-}
-function get_expr_of_stmt(statement) {
-    if (isExpressionStatement(statement))
-        return statement;
-    if (isVariableStatement(statement)) {
-        const { declarations } = statement.declarationList;
-        return factory.createExpressionStatement(declarations.length === 1 ?
-            (() => {
-                const { name } = declarations[0];
-                if (isIdentifier(name)) // const a = c
-                    return name;
-                else // const { a, b } = c
-                    return factory.createObjectLiteralExpression(name.elements
-                        .filter(({ name }) => name && isIdentifier(name))
-                        .map(({ name }) => factory.createShorthandPropertyAssignment(name)));
-            })()
-            :
-                factory.createObjectLiteralExpression(declarations.map(var_decl => factory.createShorthandPropertyAssignment(var_decl.name)), true));
-    }
-    if (isFunctionDeclaration(statement))
-        return factory.createExpressionStatement(statement.name);
-    return statement;
-}
-function trans_return_2_expr(stmt) {
-    if (!isReturnStatement(stmt))
-        return stmt;
-    return factory.createExpressionStatement(stmt.expression);
-}
-function assign_var_decl(var_decl, destination = 'globalThis') {
-    if (!isVariableStatement(var_decl))
-        return [var_decl];
-    // VariableDeclaration[] -> ObjectLiteral[]
-    // const a = 123, b = 234, { c, d: e } = obj
-    const obj_literal = factory.createObjectLiteralExpression(var_decl.declarationList.declarations.map(declaration => isIdentifier(declaration.name) ?
-        [factory.createShorthandPropertyAssignment(declaration.name)]
-        : // ObjectBindingPattern
-            declaration.name.elements.map((element) => factory.createShorthandPropertyAssignment(element.name))).flat(), true);
-    return [
-        var_decl,
-        factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('Object'), 'assign'), [], [factory.createIdentifier(destination), obj_literal])),
-        factory.createExpressionStatement(obj_literal)
-    ];
-}
-function return_last_expr(statements) {
-    if (!statements.length)
-        return statements;
-    const last_expr = get_expr_of_stmt(statements.last);
-    if (isExpressionStatement(last_expr))
-        return [...statements.slice(0, -1), factory.createReturnStatement(last_expr.expression)];
-    else
-        return statements;
-}
-function wrap_await_stmt(statements, code) {
-    function wrap(stmts) {
-        return [
-            factory.createExpressionStatement(factory.createCallExpression(factory.createFunctionExpression([factory.createModifier(SyntaxKind.AsyncKeyword)], undefined, 'async_wrapper', [], [], undefined, factory.createBlock(return_last_expr(stmts.map(statement => assign_var_decl(statement)).flat()), true)), [], [])),
-        ];
-    }
-    if (!code.includes('await'))
-        return statements;
-    if (code.includes('await') && !code.includes('async '))
-        return wrap(statements);
-    if (statements.some(stmt => (isExpressionStatement(stmt) && isAwaitExpression(stmt.expression) ||
-        isVariableStatement(stmt) && stmt.declarationList.declarations.some(var_decl => var_decl.initializer && isAwaitExpression(var_decl.initializer)) ||
-        isExpressionStatement(stmt) && isCallExpression(stmt.expression) && stmt.expression.arguments.some(expr => isAwaitExpression(expr)) ||
-        isExpressionStatement(stmt) && isBinaryExpression(stmt.expression) && isAwaitExpression(stmt.expression.right))))
-        return wrap(statements);
-    return statements;
-}
-export async function compile_ts({ fp, code, print = printing_compiled_js, save = false, } = {}) {
-    if (!code && fp)
-        code = await fread(fp);
-    const source_file = parse_code(code);
-    let statements = [...source_file.statements];
-    statements = statements.map(trans_import_2_require).flat();
-    statements = statements.map(trans_export_stmt);
-    statements = statements.map(trans_class_decl_2_expr);
-    statements = wrap_await_stmt(statements, code);
-    statements = statements.map(trans_variable_decl_2_var);
-    statements = statements.map(trans_return_2_expr);
-    if (statements.length) {
-        const last_stmt = statements[statements.length - 1];
-        const last_expr = get_expr_of_stmt(last_stmt);
-        if (last_expr !== last_stmt)
-            statements = [...statements, last_expr];
-    }
-    code = generate_code(statements);
-    let { diagnostics, outputText: output_text } = ts.transpileModule(code, { compilerOptions: ts_options_commonjs_repl });
-    if (diagnostics.length) {
-        console.log(diagnostics.join('\n\n\n'));
-        log_line();
-    }
-    if (print) {
-        console.log(output_text);
-        log_line();
-    }
-    if (fp && save)
-        await fwrite(fp.replace(/\.ts(x?)$/, '.js$1'), output_text);
-    return output_text;
-}
-/** tsconfig.compilerOptions */
-export let ts_options;
-export let ts_options_commonjs;
-export let ts_options_commonjs_repl;
-export async function load_tsconfig() {
-    const fp = `${fpd_root}tsconfig.json`;
-    ({ config: { compilerOptions: ts_options } } = ts.parseConfigFileTextToJson(fp, await fread(fp, { print: false })));
-    ts_options_commonjs = {
-        ...ts_options,
-        module: 'CommonJS',
-        incremental: false,
-        // determine CommonJS module require method
-        esModuleInterop: true,
-    };
-    ts_options_commonjs_repl = {
-        ...ts_options,
-        module: 'CommonJS',
-        esModuleInterop: true,
-        // nvm.runInThisContext doesn't support inline source map
-        sourceMap: false,
-    };
-}
-let eval_id = 0;
-export async function eval_ts(code) {
-    return nvm.runInThisContext(await compile_ts({ code }), `repl/${eval_id++}.ts`);
-}
-// ------------------------------------ repl
-export async function repl_ts(code) {
-    console.log(); // 离之前的输出有一个空行
-    const timer = new Timer();
-    const __ = globalThis.__ = await eval_ts(code);
-    timer.stop();
-    console.log(inspect(__, { limit: inspection_limit }));
-    if (timer.get() >= 500)
-        timer.print();
-    return __;
-}
 export async function start_repl() {
     // ------------ 加载库
     console.log(t('xshell 开始启动').yellow);
@@ -269,7 +29,6 @@ export async function start_repl() {
     process.title = 'xshell';
     await Promise.all([
         pollute_global(),
-        load_tsconfig(),
         (async () => {
             // --- http server
             let { Server } = await import('./server.js');
@@ -281,9 +40,6 @@ export async function start_repl() {
                             console.log('echo:', data);
                             return [data];
                         },
-                        async repl_ts({ data: [code] }) {
-                            return [await repl_ts(code)];
-                        }
                     }
                 })
             });
@@ -323,10 +79,6 @@ export async function pollute_global() {
         exports: globalThis
     });
     await Promise.all([
-        pollute_module_default_export('lodash/omit.js', 'omit'),
-        pollute_module_default_export('lodash/sortBy.js', 'sort_by'),
-        pollute_module_default_export('lodash/groupBy.js', 'group_by'),
-        pollute_module_default_export('qs', 'qs'),
         pollute_module_exports('./path.js'),
         pollute_module_exports('./prototype.js'),
         pollute_module_exports('./utils.js'),

package/server.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
 import { type Server as HttpServer } from 'http';
-import { WebSocketServer } from 'ws';
-import { default as Koa, type Context, type Next } from 'koa';
-import { type UserAgentContext } from 'koa-useragent';
+import type { WebSocketServer } from 'ws';
+import type { default as Koa, Context, Next } from 'koa';
+import type { UserAgentContext } from 'koa-useragent';
 declare module 'koa' {
     interface Request {
         /** 经过 decodeURIComponent 后，在路径重写之前的路径 */

package/server.js

@@ -3,16 +3,7 @@ import zlib from 'zlib';
 import { createReadStream } from 'fs';
 import { Readable } from 'stream';
 import util from 'util';
-// --- 3rd party
-import qs from 'qs';
-import resolve_safely from 'resolve-path';
-import { WebSocketServer } from 'ws';
-import { contentType } from 'mime-types';
-// --- koa & koa middleware
-import { default as Koa } from 'koa';
-import KoaCors from '@koa/cors';
-import KoaCompress from 'koa-compress';
-import { userAgent as KoaUserAgent } from 'koa-useragent';
+import querystring from 'querystring';
 // --- my libs
 import { t } from './i18n/instance.js';
 import { request as _request } from './net.js';
@@ -45,6 +36,11 @@ export class Server {
     }
     /** start http server and listen */
     async start() {
+        const { default: Koa } = await import('koa');
+        const { default: KoaCors } = await import('@koa/cors');
+        const { default: KoaCompress } = await import('koa-compress');
+        const { userAgent: KoaUserAgent } = await import('koa-useragent');
+        const { WebSocketServer } = await import('ws');
         // --- init koa app
         let app = new Koa();
         app.on('error', (error, ctx) => {
@@ -138,7 +134,7 @@ export class Server {
         if (ctx.is('application/json') || ctx.is('text/plain'))
             request.body = JSON.parse(req.body.toString());
         else if (ctx.is('application/x-www-form-urlencoded'))
-            request.body = qs.parse(req.body.toString());
+            request.body = querystring.parse(req.body.toString());
         else if (ctx.is('multipart/form-data'))
             throw new Error('multipart/form-data is not supported');
         else
@@ -315,6 +311,7 @@ export class Server {
                 fp = fp.slice(root.length);
             if (fp.startsWith('/'))
                 fp = fp.slice(1);
+            const { default: resolve_safely } = await import('resolve-path');
             try {
                 fp = resolve_safely(root, fp).fp;
             }
@@ -347,8 +344,9 @@ export class Server {
         if (download)
             response.set('content-disposition', `attachment; filename="${encodeURIComponent(fp.fname)}"`);
         if (!response.get('content-type')) {
+            const { contentType: get_content_type } = await import('mime-types');
             const fext = fp.fext;
-            response.set('content-type', (this.js_exts.has(fext) ? 'text/javascript; chatset=utf-8' : contentType(fp.fext))
+            response.set('content-type', (this.js_exts.has(fext) ? 'text/javascript; chatset=utf-8' : get_content_type(fp.fext))
                 || 'application/octet-stream');
         }
         if (request.fresh) {

package/utils.browser.js

@@ -138,7 +138,7 @@ export function delta2str(delta) {
         return '0 ms';
     // [1, 1000) ms
     if (delta < 1000)
-        return `${delta} ms`;
+        return `${delta.toFixed(0)} ms`;
     // 1.123 s
     if (1000 <= delta && delta < 1000 * 60)
         return `${(delta / 1000).toFixed(1)} s`;

package/utils.js

@@ -101,7 +101,7 @@ export function delta2str(delta) {
         return '0 ms';
     // [1, 1000) ms
     if (delta < 1000)
-        return `${delta} ms`;
+        return `${delta.toFixed(0)} ms`;
     // 1.123 s
     if (1000 <= delta && delta < 1000 * 60)
         return `${(delta / 1000).toFixed(1)} s`;