xshell 1.3.1 → 1.3.3

package/file.d.ts

@@ -218,33 +218,6 @@ export declare function flink(fp_real: string, fp_link: string, { skip_existing,
     print?: boolean;
     junction?: boolean;
 }): Promise<void>;
-export interface ZipOptions {
-    dirname?: string;
-    print?: {
-        info: boolean;
-        files: boolean;
-    };
-}
-/** 将文件夹或文件列表压缩为 zip，返回生成的压缩包路径 (fp_zip)
-    - data:
-        - fpd_src: 被压缩文件夹路径 (string) 或
-        - entries: 文件列表 (Record<压缩后相对路径, 原文件绝对路径 (string) | 数据 (Uint8Array)>)
-    - fp_zip: 生成的压缩包路径 (string)
-    - options?:
-        - dirname?: `fpd_src.fname` 传入 fpd_src 才生效，修改 zip 中顶层的文件夹的名字（需要以 / 结尾），如 'web/', 为空字符串时去掉顶层文件夹，不要多一个文件夹层级 (flat)
-        - print?:
-            - info?: `true` 开始压缩、压缩完成
-            - files?: `true` 打印压缩文件列表 */
-export declare function fzip(data: string | Record<string, string | Uint8Array>, fp_zip: string, options?: ZipOptions): Promise<string>;
-/** 将文件夹或文件列表压缩为 zip，返回压缩包数据 (Uint8Array)
-    - data:
-        - fpd_src: 被压缩文件夹路径 (string) 或
-        - entries: 文件列表 (Record<压缩后相对路径, 原文件绝对路径 (string) | 数据 (Uint8Array)>)
-    - options?:
-        - print?:
-            - info?: `true` 开始压缩、压缩完成
-            - files?: `true` 打印压缩文件列表 */
-export declare function zip(data: string | Record<string, string | Uint8Array>, options?: ZipOptions): Promise<Buffer>;
 export interface UnzipOptions {
     encoding?: Encoding;
     dryrun?: boolean;

package/file.js

@@ -4,7 +4,7 @@ import { t } from "./i18n/instance.js";
 import { noop, to_json } from "./prototype.js";
 import { pack, parse } from "./io.common.js";
 import { path } from "./path.js";
-import { check, Lock, WritableMemoryStream, url_width, throttle, decode, strcmp } from "./utils.js";
+import { check, Lock, url_width, throttle, decode, strcmp } from "./utils.js";
 import { noprint } from "./process.js";
 export { fsp };
 export const encodings = ['utf-8', 'gb18030', 'shift-jis', 'utf-16le'];
@@ -481,90 +481,6 @@ export async function flink(fp_real, fp_link, { skip_existing = false, print = t
     else
         await fsp.symlink(fp_real, fp_link, is_fpd_real ? 'dir' : 'file');
 }
-/** 将文件夹或文件列表压缩为 zip，返回生成的压缩包路径 (fp_zip)
-    - data:
-        - fpd_src: 被压缩文件夹路径 (string) 或
-        - entries: 文件列表 (Record<压缩后相对路径, 原文件绝对路径 (string) | 数据 (Uint8Array)>)
-    - fp_zip: 生成的压缩包路径 (string)
-    - options?:
-        - dirname?: `fpd_src.fname` 传入 fpd_src 才生效，修改 zip 中顶层的文件夹的名字（需要以 / 结尾），如 'web/', 为空字符串时去掉顶层文件夹，不要多一个文件夹层级 (flat)
-        - print?:
-            - info?: `true` 开始压缩、压缩完成
-            - files?: `true` 打印压缩文件列表 */
-export async function fzip(data, fp_zip, options) {
-    return _zip(data, fp_zip, options);
-}
-/** 将文件夹或文件列表压缩为 zip，返回压缩包数据 (Uint8Array)
-    - data:
-        - fpd_src: 被压缩文件夹路径 (string) 或
-        - entries: 文件列表 (Record<压缩后相对路径, 原文件绝对路径 (string) | 数据 (Uint8Array)>)
-    - options?:
-        - print?:
-            - info?: `true` 开始压缩、压缩完成
-            - files?: `true` 打印压缩文件列表 */
-export async function zip(data, options) {
-    return _zip(data, undefined, options);
-}
-async function _zip(data, fp_zip, { dirname, print = { files: true, info: true } } = {}) {
-    let entries;
-    let fpd_src;
-    if (typeof data === 'string') {
-        if (!path.isAbsolute(data) || !data.isdir)
-            throw new Error('fpd_src 必须是绝对路径且以 / 结尾');
-        fpd_src = data;
-        if (dirname === undefined)
-            dirname = fpd_src.fname;
-        if (!dirname.isdir)
-            throw new Error('dirname 需要以 / 结尾');
-        entries = Object.fromEntries((await flist(fpd_src, noprint))
-            .map(fp => ([dirname + fp, fpd_src + fp])));
-    }
-    else {
-        check(!dirname, 'dirname 在传入 fpd_src 时才生效');
-        entries = data;
-    }
-    if (print.info)
-        log_action('开始压缩', fpd_src ? ` ${fpd_src}` : '文件索引', fp_zip ? `${fp_zip}/${dirname || '{entries}'}` : '内存');
-    const { default: archiver } = await import('archiver');
-    let archive = archiver('zip');
-    let ostream = fp_zip ?
-        fs.createWriteStream(fp_zip, { highWaterMark: 16 * 2 ** 20 /* 16 MB */ })
-        :
-            new WritableMemoryStream();
-    const size = await new Promise(async (resolve, reject) => {
-        ostream.once('close', () => {
-            resolve(archive.pointer());
-        });
-        ostream.once('error', reject);
-        archive.once('error', reject);
-        archive.on('warning', error => {
-            console.log(error);
-        });
-        archive.pipe(ostream);
-        for (const fp in entries) {
-            const fdata = entries[fp];
-            if (fdata instanceof Uint8Array) {
-                if (print.files)
-                    log_action('压缩', fdata.length.to_fsize_str(), fp);
-                archive.append(Buffer.isBuffer(fdata) ? fdata : Buffer.from(fdata.buffer), { name: fp });
-            }
-            else {
-                check(fp.isdir === fdata.isdir);
-                check(path.isAbsolute(fdata));
-                if (print.files)
-                    log_action('压缩', fdata, fp);
-                if (fp.isdir)
-                    archive.directory(fdata, fp);
-                else
-                    archive.file(fdata, { name: fp });
-            }
-        }
-        await archive.finalize();
-    });
-    if (print.info)
-        console.log(`压缩完成，总大小 ${size.to_fsize_str()}`);
-    return fp_zip || ostream.pbuffer;
-}
 /** 解压 zip 包至文件夹，返回 fpd_out
      - zip:
         - 包路径 (string) 或

package/fzip.d.ts

@@ -0,0 +1,28 @@
+export interface ZipOptions {
+    dirname?: string;
+    print?: {
+        info: boolean;
+        files: boolean;
+    };
+}
+/** 将文件夹或文件列表压缩为 zip，返回生成的压缩包路径 (fp_zip)
+    - data:
+        - fpd_src: 被压缩文件夹路径 (string) 或
+        - entries: 文件列表 (Record<压缩后相对路径, 原文件绝对路径 (string) | 数据 (Uint8Array)>)
+    - fp_zip: 生成的压缩包路径 (string)
+    - options?:
+        - dirname?: `fpd_src.fname` 传入 fpd_src 才生效，修改 zip 中顶层的文件夹的名字（需要以 / 结尾），如 'web/', 为空字符串时去掉顶层文件夹，不要多一个文件夹层级 (flat)
+        - print?:
+            - info?: `true` 开始压缩、压缩完成
+            - files?: `true` 打印压缩文件列表 */
+export declare function fzip(data: string | Record<string, string | Uint8Array>, fp_zip: string, options?: ZipOptions): Promise<string>;
+/** 将文件夹或文件列表压缩为 zip，返回压缩包数据 (Uint8Array)
+    - data:
+        - fpd_src: 被压缩文件夹路径 (string) 或
+        - entries: 文件列表 (Record<压缩后相对路径, 原文件绝对路径 (string) | 数据 (Uint8Array)>)
+    - options?:
+        - dirname?: `fpd_src.fname` 传入 fpd_src 才生效，修改 zip 中顶层的文件夹的名字（需要以 / 结尾），如 'web/', 为空字符串时去掉顶层文件夹，不要多一个文件夹层级 (flat)
+        - print?:
+            - info?: `true` 开始压缩、压缩完成
+            - files?: `true` 打印压缩文件列表 */
+export declare function zip(data: string | Record<string, string | Uint8Array>, options?: ZipOptions): Promise<Buffer>;

package/fzip.js

@@ -0,0 +1,91 @@
+import fs from 'node:fs';
+import { path } from "./path.js";
+import { flist, log_action } from "./file.js";
+import { noprint } from "./process.js";
+import { WritableMemoryStream, check } from "./utils.js";
+/** 将文件夹或文件列表压缩为 zip，返回生成的压缩包路径 (fp_zip)
+    - data:
+        - fpd_src: 被压缩文件夹路径 (string) 或
+        - entries: 文件列表 (Record<压缩后相对路径, 原文件绝对路径 (string) | 数据 (Uint8Array)>)
+    - fp_zip: 生成的压缩包路径 (string)
+    - options?:
+        - dirname?: `fpd_src.fname` 传入 fpd_src 才生效，修改 zip 中顶层的文件夹的名字（需要以 / 结尾），如 'web/', 为空字符串时去掉顶层文件夹，不要多一个文件夹层级 (flat)
+        - print?:
+            - info?: `true` 开始压缩、压缩完成
+            - files?: `true` 打印压缩文件列表 */
+export async function fzip(data, fp_zip, options) {
+    return _zip(data, fp_zip, options);
+}
+/** 将文件夹或文件列表压缩为 zip，返回压缩包数据 (Uint8Array)
+    - data:
+        - fpd_src: 被压缩文件夹路径 (string) 或
+        - entries: 文件列表 (Record<压缩后相对路径, 原文件绝对路径 (string) | 数据 (Uint8Array)>)
+    - options?:
+        - dirname?: `fpd_src.fname` 传入 fpd_src 才生效，修改 zip 中顶层的文件夹的名字（需要以 / 结尾），如 'web/', 为空字符串时去掉顶层文件夹，不要多一个文件夹层级 (flat)
+        - print?:
+            - info?: `true` 开始压缩、压缩完成
+            - files?: `true` 打印压缩文件列表 */
+export async function zip(data, options) {
+    return _zip(data, undefined, options);
+}
+async function _zip(data, fp_zip, { dirname, print = { files: true, info: true } } = {}) {
+    let entries;
+    let fpd_src;
+    if (typeof data === 'string') {
+        if (!path.isAbsolute(data) || !data.isdir)
+            throw new Error('fpd_src 必须是绝对路径且以 / 结尾');
+        fpd_src = data;
+        if (dirname === undefined)
+            dirname = fpd_src.fname;
+        if (!dirname.isdir)
+            throw new Error('dirname 需要以 / 结尾');
+        entries = Object.fromEntries((await flist(fpd_src, noprint))
+            .map(fp => ([dirname + fp, fpd_src + fp])));
+    }
+    else {
+        check(!dirname, 'dirname 在传入 fpd_src 时才生效');
+        entries = data;
+    }
+    if (print.info)
+        log_action('开始压缩', fpd_src ? ` ${fpd_src}` : '文件索引', fp_zip ? `${fp_zip}/${dirname || '{entries}'}` : '内存');
+    const { default: archiver } = await import('archiver');
+    let archive = archiver('zip');
+    let ostream = fp_zip ?
+        fs.createWriteStream(fp_zip, { highWaterMark: 16 * 2 ** 20 /* 16 MB */ })
+        :
+            new WritableMemoryStream();
+    const size = await new Promise(async (resolve, reject) => {
+        ostream.once('close', () => {
+            resolve(archive.pointer());
+        });
+        ostream.once('error', reject);
+        archive.once('error', reject);
+        archive.on('warning', error => {
+            console.log(error);
+        });
+        archive.pipe(ostream);
+        for (const fp in entries) {
+            const fdata = entries[fp];
+            if (fdata instanceof Uint8Array) {
+                if (print.files)
+                    log_action('压缩', fdata.length.to_fsize_str(), fp);
+                archive.append(Buffer.isBuffer(fdata) ? fdata : Buffer.from(fdata.buffer), { name: fp });
+            }
+            else {
+                check(fp.isdir === fdata.isdir);
+                check(path.isAbsolute(fdata));
+                if (print.files)
+                    log_action('压缩', fdata, fp);
+                if (fp.isdir)
+                    archive.directory(fdata, fp);
+                else
+                    archive.file(fdata, { name: fp });
+            }
+        }
+        await archive.finalize();
+    });
+    if (print.info)
+        console.log(`压缩完成，总大小 ${size.to_fsize_str()}`);
+    return fp_zip || ostream.pbuffer;
+}
+//# sourceMappingURL=fzip.js.map

package/net.common.d.ts

@@ -100,6 +100,8 @@ export interface RemoteOptions {
     /** 使用者自定义的在 websocket 连接出错时，或者 handlers 出错时的处理
         用户设置后会覆盖默认的 print 错误功能 */
     on_error?(error: WebSocketConnectionError | Error, remote: Remote): void;
+    /** 使用者自定义的，在重连之前调用的函数，比如可以修改 url，仅连接发起方有效 */
+    on_reconnect?(this: Remote): Promise<void>;
 }
 /** 通过创建 remote 对象对 websocket rpc 进行抽象
     使用 remote.call() 进行一元 rpc
@@ -146,10 +148,11 @@ export declare class Remote {
     error: WebSocketConnectionError | Error;
     /** 作为 websocket 连接发起方，传入 url
         作为 websocket 连接接收方，传入 websocket + name */
-    constructor({ name, url, websocket, funcs, print, verbose, probe, args, on_error, }?: RemoteOptions);
+    constructor({ name, url, websocket, funcs, print, verbose, probe, args, on_error, on_reconnect }?: RemoteOptions);
     /** 统一处理首次连接和连接后的 websocket 错误 */
     _on_error: (error: WebSocketConnectionError | Error) => void;
-    reconnect: () => void;
+    on_reconnect?: (this: Remote) => Promise<void>;
+    reconnect: () => Promise<void>;
     _on_message: (data: ArrayBuffer) => void;
     /** 使用者自定义的在 websocket 连接出错时，或者 handlers 出错时的处理
         用户设置后会覆盖默认的 print 错误功能 */

package/net.common.js

@@ -238,12 +238,14 @@ export class Remote {
     error;
     /** 作为 websocket 连接发起方，传入 url
         作为 websocket 连接接收方，传入 websocket + name */
-    constructor({ name, url, websocket, funcs, print, verbose, probe, args, on_error, } = {}) {
+    constructor({ name, url, websocket, funcs, print, verbose, probe, args, on_error, on_reconnect } = {}) {
         if (name)
             this.name = name;
         if (url) {
             check(!websocket, '构建 Remote 时 url 和 websocket 只能传其中一个');
             this.url = url;
+            if (on_reconnect)
+                this.on_reconnect = on_reconnect;
         }
         else { // 连接接收方，一定是 nodejs 环境
             check(websocket, '构建 Remote 时需传入 url 或者 websocket');
@@ -313,8 +315,11 @@ export class Remote {
         }
         this.on_error(error, this);
     };
-    reconnect = () => {
+    on_reconnect;
+    reconnect = async () => {
         this.reconnecting = null;
+        if (this.on_reconnect)
+            await this.on_reconnect();
         this.try_connect();
     };
     _on_message = (data) => {

package/package.json

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