xshell 1.3.49 → 1.3.51

package/file.d.ts

@@ -259,10 +259,6 @@ export declare function funzip(zip: string | Uint8Array | ArrayBuffer, fpd_out:
         - filter?: 用于过滤要解压的文件, 返回 falsy 值时忽略这个文件，要注意 file.name 为完整的相对路径（没有 strip） */
 export declare function unzip(zip: string | Uint8Array | ArrayBuffer, options?: UnzipOptions): Promise<Record<string, Uint8Array>>;
 export declare let fwatchers: Record<string, fs.FSWatcher>;
-/** 跟踪文本文件追加的内容，类似 tail -f */
-export declare function ftail(fp: string, handler: (lines: string[]) => void | Promise<void>, { print }?: {
-    print?: boolean;
-}): Promise<fs.FSWatcher>;
 /** 打开一个文件并搜索替换某个 pattern */
 export declare function freplace(fp: string, pattern: string | RegExp, replacement: string | ((substring: string, ...args: any[]) => string), { print }?: {
     print?: boolean;
@@ -286,5 +282,5 @@ export declare function fp_sorter(l: {
     fp: string;
 }, r: {
     fp: string;
-}): 0 | 1 | -1;
+}): 1 | 0 | -1;
 export declare function log_action(action: string, fp_src: string, fp_dst: string, sep?: string): void;

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, url_width, throttle, decode, strcmp } from "./utils.js";
+import { check, url_width, decode, strcmp } from "./utils.js";
 import { noprint } from "./process.js";
 export { fsp };
 export const encodings = ['utf-8', 'gb18030', 'shift-jis', 'utf-16le'];
@@ -699,52 +699,6 @@ const ftrashes = new Set([
     'yarn.lock',
 ].map(f => f.toLowerCase()));
 export let fwatchers = {};
-/** 跟踪文本文件追加的内容，类似 tail -f */
-export async function ftail(fp, handler, { print = true } = {}) {
-    fwatchers[fp]?.close();
-    const { size } = await fstat(fp);
-    let pointer = Number(size);
-    let lock = new Lock(await fopen(fp));
-    let fbuf = Buffer.allocUnsafe(2 ** 20);
-    let strbuf = '';
-    let decoder = new TextDecoder();
-    if (print)
-        console.log('开始跟踪追加内容', fp);
-    const onchange_throttled = throttle(250, async () => {
-        if (lock.locked)
-            return;
-        await lock.request(async (handle) => {
-            const { bytesRead } = await handle.read(fbuf, 0, fbuf.length, pointer);
-            pointer += bytesRead;
-            const chunk = decoder.decode(fbuf.subarray(0, bytesRead), { stream: true });
-            let lines = [];
-            let j = 0;
-            for (let i = 0; (i = chunk.indexOf('\n', j)) >= 0;) {
-                let line = chunk.slice(j, i);
-                if (strbuf) {
-                    line = strbuf + line;
-                    strbuf = '';
-                }
-                j = i + 1;
-                lines.push(line);
-            }
-            strbuf = chunk.slice(j);
-            await handler(lines);
-        });
-    });
-    let watcher = fs.watch(fp, event => {
-        if (event === 'change')
-            onchange_throttled();
-        else {
-            console.error(`被监听的文件 ${fp.quote()} 出现了 rename 事件，结束 ftail`);
-            watcher.close();
-        }
-    });
-    watcher.on('error', error => {
-        console.error(error);
-    });
-    return fwatchers[fp] = watcher;
-}
 /** 打开一个文件并搜索替换某个 pattern */
 export async function freplace(fp, pattern, replacement, { print = true } = {}) {
     await fwrite(fp, (await fread(fp, noprint))

package/net.d.ts

@@ -37,7 +37,7 @@ export interface RequestOptions {
     queries?: Record<string, any>;
     headers?: Record<string, string>;
     body?: string | Record<string, any> | Uint8Array | URLSearchParams | Readable;
-    type?: 'application/json' | 'application/x-www-form-urlencoded' | 'multipart/form-data';
+    type?: 'application/json' | 'application/x-www-form-urlencoded' | 'multipart/form-data' | 'application/jose+json';
     proxy?: boolean | ValueOf<typeof MyProxy> | string;
     encoding?: Encoding | 'binary';
     retries?: true | number;
@@ -46,6 +46,9 @@ export interface RequestOptions {
     cookies?: Record<string, string>;
     redirect?: 'follow' | 'manual';
     decode?: boolean;
+    dryrun?: boolean;
+    browser?: boolean;
+    ua?: string;
     print?: {
         retry: boolean;
         timeout: boolean;
@@ -96,6 +99,9 @@ export declare class StatusCodeError extends Error {
         - raw?: `false` 传入后返回整个 response (RawResponse)，body 为 Readable
         - full?: `false` 传入后返回整个 response (FullResponse)，body 根据 encoding 对应为 string 或 Buffer
         - decode?: `true` 根据 content-encoding: br 等解码压缩后的 response.body
+        - browser?: `false` 使用 chrome 浏览器的 ua
+        - ua?: `无 user-agent 头` 快捷设置 user-agent 头，默认不发送
+        - dryrun?: `false` 仅打印 undici options, 并不实际发送请求，返回 undefined
         - print?:
             - retry: `true` 是否打印 "等待 1 秒后重试 request" 提示信息
             - timeout: `true` 是否打印最后一次超时重试失败时的错误 */

package/net.js

@@ -67,7 +67,7 @@ export async function request(url, options = {}) {
     undici ??= (await import('undici')).default;
     const { Cookie } = await import('tough-cookie');
     await cookies.init();
-    const { queries, headers: _headers, body, type = 'application/json', timeout = 5 * 1000, auth, cookies: _cookies, raw = false, full = false, redirect = 'follow', decode = true, print = {
+    const { queries, headers: _headers, body, type = 'application/json', timeout = 5 * 1000, auth, cookies: _cookies, raw = false, full = false, redirect = 'follow', decode = true, dryrun, ua, browser: browser_ua, print = {
         timeout: true,
         retry: true
     } } = options;
@@ -87,11 +87,16 @@ export async function request(url, options = {}) {
         retries = 2;
     // --- headers, http/2 开始都用小写的 headers
     let headers = {
-        'accept-language': 'zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7,ja-JP;q=0.6,ja;q=0.5',
-        'accept-encoding': 'gzip, deflate, br',
-        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36',
-        'sec-ch-ua-platform': '"Windows"',
-        'sec-ch-ua-platform-version': '"19.0.0"',
+        'accept-language': 'zh-CN,zh;q=0.9',
+        'accept-encoding': 'gzip, deflate, br, zstd',
+        ...browser_ua ? {
+            'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36',
+            'sec-ch-ua-platform': '"Windows"',
+            'sec-ch-ua-platform-version': '"19.0.0"'
+        } : {},
+        ...ua ? {
+            'user-agent': ua
+        } : {}
     };
     // https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest_API/Using_FormData_Objects
     // When using FormData to submit POST requests using XMLHttpRequest or the Fetch API with the multipart/form-data content type (e.g., when uploading files and blobs to the server), 
@@ -137,6 +142,10 @@ export async function request(url, options = {}) {
         headers,
         body: get_request_body(body, type)
     };
+    if (dryrun) {
+        console.log(undici_options);
+        return;
+    }
     let response;
     try {
         const { statusCode: status, headers: _headers, body: _body } = await request_retry(url, undici_options, timeout, retries, 0, print);
@@ -253,7 +262,7 @@ function get_request_body(body, type) {
         return undefined;
     if (typeof body?.read === 'function' && isReadable(body))
         return body;
-    if (type === 'application/json') {
+    if (type === 'application/json' || type === 'application/jose+json') {
         // 可能的类型 string | Record<string, any> | Uint8Array
         if (typeof body === 'string')
             return encode(body);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "xshell",
-    "version": "1.3.49",
+    "version": "1.3.51",
     "type": "module",
     "main": "./index.js",
     "bin": {
@@ -69,13 +69,13 @@
         "https-proxy-agent": "^8.0.0",
         "i18next": "25.8.1",
         "i18next-scanner": "^4.6.0",
-        "koa": "^3.1.2",
+        "koa": "^3.2.0",
         "koa-compress": "^5.2.1",
         "license-webpack-plugin": "^4.0.2",
         "mime-types": "^3.0.2",
         "p-map": "^7.0.4",
         "react": "^19.2.4",
-        "react-i18next": "^16.6.2",
+        "react-i18next": "^17.0.1",
         "resolve-path": "^1.4.0",
         "sass": "^1.98.0",
         "sass-loader": "^16.0.7",
@@ -86,9 +86,9 @@
         "ts-loader": "^9.5.4",
         "tslib": "^2.8.1",
         "typescript": "^6.0.2",
-        "undici": "^7.24.5",
+        "undici": "^7.24.6",
         "webpack": "^5.105.4",
-        "webpack-bundle-analyzer": "^5.2.0",
+        "webpack-bundle-analyzer": "^5.3.0",
         "ws": "^8.20.0"
     },
     "devDependencies": {

package/prototype.common.d.ts

@@ -238,6 +238,8 @@ export type Less = Greater;
 export declare const less: Less;
 export type ValueOf<T> = T[keyof T];
 export declare function to_snake_case(str: string): string;
+export declare function to_lower_camel_case(str: string): string;
+export declare function to_upper_camel_case(str: string): string;
 export declare function to_space_case(str: string): string;
 /** 在常量对象上添加反向映射（value -> key）
     ```ts

package/prototype.common.js

@@ -17,13 +17,22 @@ export function rethrow(error) {
 export const greater = (a, b) => a > b;
 export const less = (a, b) => a < b;
 export function to_snake_case(str) {
-    return str.replace(/([A-Z])/g, '_$1')
+    return str.replaceAll(/([A-Z])/g, '_$1')
         .toLowerCase()
-        .replace('-', '_')
+        .replaceAll('-', '_')
         .strip_if_start('_');
 }
+export function to_lower_camel_case(str) {
+    return str.replaceAll(/_([a-z])/g, match => match[1].toUpperCase());
+}
+export function to_upper_camel_case(str) {
+    if (!str)
+        return str;
+    const s = to_lower_camel_case(str);
+    return s[0].toUpperCase() + s.slice(1);
+}
 export function to_space_case(str) {
-    return str.replace(/([A-Z])/g, ' $1')
+    return str.replaceAll(/([A-Z])/g, ' $1')
         .toLowerCase()
         .replaceAll('_', ' ')
         .strip_if_start(' ');

package/utils.common.d.ts

@@ -21,7 +21,7 @@ export declare function seq<T = number>(n: number, generator?: (index: number) =
     - mapper?: 可以是 key (string, number, symbol) 或 (obj: any) => any */
 export declare function unique<TObj>(iterable: TObj[] | Iterable<TObj>, mapper?: keyof TObj | Mapper<TObj>): TObj[];
 /** 字符串字典序比较 */
-export declare function strcmp(l: string, r: string): 0 | 1 | -1;
+export declare function strcmp(l: string, r: string): 1 | 0 | -1;
 /** 排序对象中 keys 的顺序，返回新的对象 */
 export declare function sort_keys<TObj>(obj: TObj): TObj;
 /** 比较 1.10.02 这种版本号
@@ -82,6 +82,9 @@ export declare function timeout<TReturn>(milliseconds: number, action: Promise<T
     action 返回 trusy 值时认为成功，返回 action 的结果
     如果次数用尽仍然失败，返回 null */
 export declare function poll<TResult>(duration: number, times: number, action: (breaker: () => void) => Promise<TResult>): Promise<TResult>;
+export declare const one_day: number;
+/** 获取到下一次 hour:minute 时钟所需 delay 的毫秒数 */
+export declare function get_delay_to_clock(hour: number, minute?: number): number;
 /** 每天在固定时间执行操作
     - hour: 0 - 23 之间的整数，在这个点执行
     - action */
@@ -176,7 +179,10 @@ export declare function grep(str: string, pattern: string | RegExp): string;
 export declare function lowercase_first_letter(str: string): string;
 /** 大于 n 的最小的 2 的幂次 */
 export declare function ceil2(n: number): number;
-/** 节流，最多只在时间间隔末尾调用一次，可以设置首次调用是否延后 */
+/** 节流，最多只在时间间隔末尾调用一次，可以设置首次调用是否延后
+    - duration
+    - func
+    - delay_first?: `false` */
 export declare function throttle(duration: number, func: Function, delay_first?: boolean): (this: any, ...args: any[]) => void;
 /** 防抖，间隔一段时间不再触发时调用，同时大幅优化减少 setTimeout, clearTimeout 的调用次数 */
 export declare function debounce(duration: number, func: Function): (this: any, ...args: any[]) => void;

package/utils.common.js

@@ -255,18 +255,24 @@ export async function poll(duration, times, action) {
     }
     return null;
 }
+export const one_day = 1000 * 60 * 60 * 24;
+/** 获取到下一次 hour:minute 时钟所需 delay 的毫秒数 */
+export function get_delay_to_clock(hour, minute = 0) {
+    const now = Date.now();
+    let today = new Date(now);
+    today.setHours(hour, minute, 0, 0);
+    let target = today.getTime();
+    // 如果目标时间已过，则设置为明天的目标时间
+    if (target <= now)
+        target += one_day;
+    return target - now;
+}
 /** 每天在固定时间执行操作
     - hour: 0 - 23 之间的整数，在这个点执行
     - action */
 export async function schedule_everyday(hour, minute, action) {
-    const now = Date.now();
-    let target = new Date();
-    target.setHours(hour, minute, 0, 0);
-    // 如果目标时间已过，设定为明天的时间
-    if (now > target.getTime())
-        target.setDate(target.getDate() + 1);
     // 等时间到
-    await delay(target.getTime() - now);
+    await delay(get_delay_to_clock(hour, minute));
     for (;;) {
         try {
             await action();
@@ -276,7 +282,7 @@ export async function schedule_everyday(hour, minute, action) {
             console.error(error);
         }
         // 等一天
-        await delay(1000 * 60 * 60 * 24);
+        await delay(one_day);
     }
 }
 /** 模糊过滤字符串列表或对象列表，常用于根据用户输入补全或搜索过滤
@@ -534,7 +540,10 @@ export function ceil2(n) {
         ;
     return power;
 }
-/** 节流，最多只在时间间隔末尾调用一次，可以设置首次调用是否延后 */
+/** 节流，最多只在时间间隔末尾调用一次，可以设置首次调用是否延后
+    - duration
+    - func
+    - delay_first?: `false` */
 export function throttle(duration, func, delay_first = false) {
     let timeout = 0;
     let last = 0;