xshell 1.2.3 → 1.2.4

package/file.js

@@ -560,6 +560,6 @@ export async function freplace(fp, pattern, replacement, { print = true } = {})
         .replaceAll(pattern, replacement), { print });
 }
 function log_action(action, fp_src, fp_dst, sep = '->') {
-    console.log(`${`${action} ${fp_src}`.pad(url_width)} ${sep} ${fp_dst}`);
+    console.log(`${`${action}  ${fp_src}`.pad(url_width)}  ${sep}  ${fp_dst}`);
 }
 //# sourceMappingURL=file.js.map

package/net.browser.d.ts

@@ -101,11 +101,8 @@ export declare function connect_websocket(url: string | URL, { protocols, on_mes
     print?: boolean;
 }): Promise<WebSocket>;
 /** 接收到消息后的处理函数
-    返回值可以是:
-    - 数组: 会自动被封装为 { id: 相同, data: 返回值, done: true } 这样的消息并调用 websocket.send 将其发送
-    - void: 什么都不做
-    - 以上的 promise */
-export type MessageHandler<TData extends any[] = any[]> = (message: Message<TData>, websocket?: WebSocket) => void | any[] | Promise<void | any[]>;
+    返回值会自动被 await，然后可能被封装为 message 回传 */
+export type MessageHandler<TData = any> = (message: Message<TData>, websocket?: WebSocket) => void | any | Promise<void | any>;
 /** 自动保持 remote 连接，只对 initiator 且传入 url 有效，
     - 在未连接，或 websocket on_error 检测到连接断开后以 reconnect_interval 间隔尝试 remote.call(func) 重连
     - 在连接状态下以 heartbeat_interval 间隔发送心跳包确保连接状态
@@ -159,7 +156,7 @@ export declare class Remote {
     funcs: Record<string, MessageHandler>;
     /** map<id, message handler>: 通过 (rpc message).id 找到对应的 handler
         一元 rpc 接收方不需要设置 handlers, 发送方需要 */
-    handlers: Map<number, MessageHandler<any[]>>;
+    handlers: Map<number, MessageHandler<any>>;
     keeper?: RemoteKeeperOptions;
     /** `true` 是否打印连接信息、错误信息 */
     print: boolean;
@@ -198,14 +195,17 @@ export declare class Remote {
         作为 websocket 连接接收方，必传 websocket 参数
         发送或连接出错时自动清理 message.id 对应的 handler */
     send(message: Message, websocket?: WebSocket): Promise<void>;
-    /** 处理接收到的 websocket message 并解析, 根据 message.id 或 message.func 分发到对应的 handler 进行处理
+    /** 处理接收到的 websocket message 并解析, 根据 message.id 或 message.func 分发到对应的 handler 进行处理，
+        handler 处理完成后:
+        - 传了 func: 调用函数的情况下 (通常是一元 rpc)，总是将返回值包装为 message 回传
+        - 未传 func: 通过 id 调用，如果 handler 返回非 undefined 的值，也包装为 message 回传
+        
         如果 message.done == true 则对端指示当前 remote 可以清理 handler
-        如果 handler 返回了值 (一定是数组)，则包装为 message 发送
         使用 Uint8Array 作为参数更灵活 https://stackoverflow.com/a/74505197/7609214
         这个方法一般不会抛出错误，也不需要 await，一般在 websocket on_message 时使用 */
     handle(data: Uint8Array, websocket: WebSocket): Promise<void>;
     /** 调用对端 remote 中的 func, 只适用于最简单的一元 rpc (请求, 响应)
         作为 websocket 连接发起方，不需要传入 websocket
         作为 websocket 连接接收方，必传 websocket 参数  */
-    call<TReturn extends any[] = any[]>(func: string, args?: any[], websocket?: WebSocket): Promise<TReturn>;
+    call<TReturn = any>(func: string, args?: any[], websocket?: WebSocket): Promise<TReturn>;
 }

package/net.browser.js

@@ -431,7 +431,6 @@ export class Remote {
         作为 websocket 连接接收方，必传 websocket 参数
         发送或连接出错时自动清理 message.id 对应的 handler */
     async send(message, websocket) {
-        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 {
@@ -445,9 +444,12 @@ export class Remote {
             throw error;
         }
     }
-    /** 处理接收到的 websocket message 并解析, 根据 message.id 或 message.func 分发到对应的 handler 进行处理
+    /** 处理接收到的 websocket message 并解析, 根据 message.id 或 message.func 分发到对应的 handler 进行处理，
+        handler 处理完成后:
+        - 传了 func: 调用函数的情况下 (通常是一元 rpc)，总是将返回值包装为 message 回传
+        - 未传 func: 通过 id 调用，如果 handler 返回非 undefined 的值，也包装为 message 回传
+        
         如果 message.done == true 则对端指示当前 remote 可以清理 handler
-        如果 handler 返回了值 (一定是数组)，则包装为 message 发送
         使用 Uint8Array 作为参数更灵活 https://stackoverflow.com/a/74505197/7609214
         这个方法一般不会抛出错误，也不需要 await，一般在 websocket on_message 时使用 */
     async handle(data, websocket) {
@@ -464,8 +466,12 @@ export class Remote {
         if (this.verbose)
             console.log('remote.handle:', message);
         let handler;
-        if (func)
+        if (func) {
             handler = this.funcs[func];
+            // 传了 func 调用函数的情况下，如果 message.data 为 undefined, 默认为 [ ]
+            if (message.data === undefined)
+                message.data = [];
+        }
         else {
             handler = this.handlers.get(id);
             if (done && handler)
@@ -474,7 +480,7 @@ export class Remote {
         try {
             if (handler) {
                 const data = await handler(message, websocket);
-                if (data)
+                if (func || data !== undefined)
                     await this.send({ id, data }, websocket);
             }
             else

package/net.d.ts

@@ -163,11 +163,8 @@ on_message, on_error, on_close, proxy, print, }: {
     print?: boolean;
 }): Promise<WebSocket>;
 /** 接收到消息后的处理函数
-    返回值可以是:
-    - 数组: 会自动被封装为 { id: 相同, data: 返回值, done: true } 这样的消息并调用 websocket.send 将其发送
-    - void: 什么都不做
-    - 以上的 promise */
-export type MessageHandler<TData extends any[] = any[]> = (message: Message<TData>, websocket?: WebSocket) => void | any[] | Promise<void | any[]>;
+    返回值会自动被 await，然后可能被封装为 message 回传 */
+export type MessageHandler<TData = any> = (message: Message<TData>, websocket?: WebSocket) => void | any | Promise<void | any>;
 /** 自动保持 remote 连接，只对 initiator 且传入 url 有效，
     - 在未连接，或 websocket on_error 检测到连接断开后以 reconnect_interval 间隔尝试 remote.call(func) 重连
     - 在连接状态下以 heartbeat_interval 间隔发送心跳包确保连接状态
@@ -221,7 +218,7 @@ export declare class Remote {
     funcs: Record<string, MessageHandler>;
     /** map<id, message handler>: 通过 (rpc message).id 找到对应的 handler
         一元 rpc 接收方不需要设置 handlers, 发送方需要 */
-    handlers: Map<number, MessageHandler<any[]>>;
+    handlers: Map<number, MessageHandler<any>>;
     keeper?: RemoteKeeperOptions;
     /** `true` 是否打印连接信息、错误信息 */
     print: boolean;
@@ -260,16 +257,19 @@ export declare class Remote {
         作为 websocket 连接接收方，必传 websocket 参数
         发送或连接出错时自动清理 message.id 对应的 handler */
     send(message: Message, websocket?: WebSocket): Promise<void>;
-    /** 处理接收到的 websocket message 并解析, 根据 message.id 或 message.func 分发到对应的 handler 进行处理
+    /** 处理接收到的 websocket message 并解析, 根据 message.id 或 message.func 分发到对应的 handler 进行处理，
+        handler 处理完成后:
+        - 传了 func: 调用函数的情况下 (通常是一元 rpc)，总是将返回值包装为 message 回传
+        - 未传 func: 通过 id 调用，如果 handler 返回非 undefined 的值，也包装为 message 回传
+        
         如果 message.done == true 则对端指示当前 remote 可以清理 handler
-        如果 handler 返回了值 (一定是数组)，则包装为 message 发送
         使用 Uint8Array 作为参数更灵活 https://stackoverflow.com/a/74505197/7609214
         这个方法一般不会抛出错误，也不需要 await，一般在 websocket on_message 时使用 */
     handle(data: Uint8Array, websocket: WebSocket): Promise<void>;
     /** 调用对端 remote 中的 func, 只适用于最简单的一元 rpc (请求, 响应)
         作为 websocket 连接发起方，不需要传入 websocket
         作为 websocket 连接接收方，必传 websocket 参数  */
-    call<TReturn extends any[] = any[]>(func: string, args?: any[], websocket?: WebSocket): Promise<TReturn>;
+    call<TReturn = any>(func: string, args?: any[], websocket?: WebSocket): Promise<TReturn>;
 }
 /** 为连接到 server 的 client 创建 RemoteClient，以便后续调用 client 中方法 */
 export declare class RemoteClient {
@@ -277,7 +277,7 @@ export declare class RemoteClient {
     websocket: WebSocket;
     constructor(remote: Remote, websocket: WebSocket);
     /** 调用 client 中的 func, 只适用于最简单的一元 rpc (请求, 响应) */
-    call<TReturn extends any[] = any[]>(func: string, args?: any[]): Promise<TReturn>;
+    call<TReturn = any>(func: string, args?: any[]): Promise<TReturn>;
     /** 发送 message 到 client
         发送或连接出错时自动清理 message.id 对应的 handler */
     send(message: Message): Promise<void>;

package/net.js

@@ -616,7 +616,6 @@ export class Remote {
         作为 websocket 连接接收方，必传 websocket 参数
         发送或连接出错时自动清理 message.id 对应的 handler */
     async send(message, websocket) {
-        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 {
@@ -630,9 +629,12 @@ export class Remote {
             throw error;
         }
     }
-    /** 处理接收到的 websocket message 并解析, 根据 message.id 或 message.func 分发到对应的 handler 进行处理
+    /** 处理接收到的 websocket message 并解析, 根据 message.id 或 message.func 分发到对应的 handler 进行处理，
+        handler 处理完成后:
+        - 传了 func: 调用函数的情况下 (通常是一元 rpc)，总是将返回值包装为 message 回传
+        - 未传 func: 通过 id 调用，如果 handler 返回非 undefined 的值，也包装为 message 回传
+        
         如果 message.done == true 则对端指示当前 remote 可以清理 handler
-        如果 handler 返回了值 (一定是数组)，则包装为 message 发送
         使用 Uint8Array 作为参数更灵活 https://stackoverflow.com/a/74505197/7609214
         这个方法一般不会抛出错误，也不需要 await，一般在 websocket on_message 时使用 */
     async handle(data, websocket) {
@@ -649,8 +651,12 @@ export class Remote {
         if (this.verbose)
             console.log('remote.handle:', message);
         let handler;
-        if (func)
+        if (func) {
             handler = this.funcs[func];
+            // 传了 func 调用函数的情况下，如果 message.data 为 undefined, 默认为 [ ]
+            if (message.data === undefined)
+                message.data = [];
+        }
         else {
             handler = this.handlers.get(id);
             if (done && handler)
@@ -659,7 +665,7 @@ export class Remote {
         try {
             if (handler) {
                 const data = await handler(message, websocket);
-                if (data)
+                if (func || data !== undefined)
                     await this.send({ id, data }, websocket);
             }
             else

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "xshell",
-    "version": "1.2.3",
+    "version": "1.2.4",
     "type": "module",
     "main": "./index.js",
     "bin": {

package/path.d.ts

@@ -54,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. */
@@ -81,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;