xshell 1.2.71 → 1.2.73

package/utils.common.d.ts

@@ -1,4 +1,6 @@
+import type { TimerOptions } from 'timers';
 import { type Mapper } from './prototype.common.ts';
+export declare function delay(milliseconds: number, options?: TimerOptions): Promise<void>;
 export declare function assert<T>(assertion: T, message?: string): T;
 /** 做参数校验，逻辑检查 */
 export declare function check<T>(condition: T, message?: string): T;
@@ -49,6 +51,30 @@ export declare function filter_values<TObj extends Record<string, any>>(obj: TOb
 export declare function pick<TObject = any>(obj: TObject, keys: (keyof TObject)[]): Partial<TObject>;
 /** 忽略对象中的 keys, 返回新对象 */
 export declare function omit<TObj>(obj: TObj, omit_keys: string[]): TObj;
+/** 拼接 TypedArrays 生成一个完整的 Uint8Array */
+export declare function concat(arrays: ArrayBufferView[]): Uint8Array<ArrayBufferLike>;
+export declare let encoder: TextEncoder;
+/** 将字符串简单的编码为 utf-8 的 buffer (Uint8Array)。高频使用或者在流式处理时，考虑使用 TextEncoder 的 encodeInto 方法 */
+export declare function encode(str: string): Uint8Array<ArrayBufferLike>;
+export declare function encode_into(str: string, buf: Uint8Array): TextEncoderEncodeIntoResult;
+/** 将 utf-8 buffer (Uint8Array) 简单的解码为 string。
+    在流式处理 (buffer 可能不完整) 时，应使用独立的 TextDecoder 实例调用 decode(buffer, { stream: true }) */
+export declare function decode(buffer: Uint8Array): string;
+/** 比较两个 buffer 内容是否相同，第二个可以传入 string 自动编码转换后比较，
+    高频调用时建议提前编码 right 并缓存 */
+export declare function buffer_equals(left: Uint8Array, right: Uint8Array | string): boolean;
+/** 在指定的时间 (milliseconds) 内运行某个任务，超时之后抛出错误或调用 on_timeout
+    - milliseconds: 限时毫秒数
+    - action?: 要等待运行的任务, async function 或 promise
+    - on_timeout?: 超时后调用的函数
+        - 如果传入了 on_timeout 参数: 调用 on_timeout，然后 timeout 函数正常返回 null
+        - 如果没传入 on_timeout 参数: 抛出 TimeoutError
+    - print?: 打印已超时任务的错误 */
+export declare function timeout<TReturn>(milliseconds: number, action: Promise<TReturn> | (() => Promise<TReturn>), on_timeout?: () => void | Promise<void>, print?: boolean): Promise<TReturn>;
+/** 轮询尝试 action 共 times 次，每次间隔 duration
+    action 返回 trusy 值时认为成功，返回 action 的结果
+    如果次数用尽仍然失败，返回 null */
+export declare function poll<TResult>(duration: number, times: number, action: (breaker: () => void) => Promise<TResult>): Promise<TResult>;
 /** 模糊过滤字符串列表或对象列表，常用于根据用户输入补全或搜索过滤
     如果有完全匹配的，只返回那一项的数组
     - query: 查询字符串，要求为全小写
@@ -127,11 +153,6 @@ export declare class Lock<TResource = void> {
     /** 通过 await lock.request() 锁定资源以便独占访问，锁定资源后在 action 回调中操作资源，回调 promise 完成 (fullfilled 或 rejected) 后自动释放资源 */
     request<TResult>(action: LockedAction<TResource, TResult>, signal?: AbortSignal): Promise<TResult>;
 }
-export declare let encoder: TextEncoder;
-export declare function encode_into(str: string, buf: Uint8Array): TextEncoderEncodeIntoResult;
-/** 将 utf-8 buffer (Uint8Array) 简单的解码为 string。
-    在流式处理 (buffer 可能不完整) 时，应使用独立的 TextDecoder 实例调用 decode(buffer, { stream: true }) */
-export declare function decode(buffer: Uint8Array): string;
 /** 过滤符合 pattern 的行 */
 export declare function grep(str: string, pattern: string | RegExp): string;
 export declare function lowercase_first_letter(str: string): string;

package/utils.common.js

@@ -1,5 +1,9 @@
 import { t } from "./i18n/instance.js";
 import { ident, is_key_type, noop, not_empty, select, to_snake_case } from "./prototype.common.js";
+import { platform } from "./platform.common.js";
+export async function delay(milliseconds, options) {
+    return platform.delay(milliseconds, options);
+}
 export function assert(assertion, message) {
     if (!assertion) {
         debugger;
@@ -135,6 +139,118 @@ export function omit(obj, omit_keys) {
     const omit_keys_ = new Set(omit_keys);
     return filter_keys(obj, key => !omit_keys_.has(key));
 }
+/** 拼接 TypedArrays 生成一个完整的 Uint8Array */
+export function concat(arrays) {
+    let length = 0;
+    for (const a of arrays)
+        length += a.byteLength;
+    let buf = platform.get_buffer(length);
+    let offset = 0;
+    for (const a of arrays) {
+        const uint8view = new Uint8Array(a.buffer, a.byteOffset, a.byteLength);
+        buf.set(uint8view, offset);
+        offset += uint8view.byteLength;
+    }
+    return buf;
+}
+export let encoder = new TextEncoder();
+/** 将字符串简单的编码为 utf-8 的 buffer (Uint8Array)。高频使用或者在流式处理时，考虑使用 TextEncoder 的 encodeInto 方法 */
+export function encode(str) {
+    return platform.encode(str);
+}
+export function encode_into(str, buf) {
+    // 这个是直接用 v8 String::WriteUtf8 最高效的方法了
+    return encoder.encodeInto(str, buf);
+}
+let decoder = new TextDecoder();
+/** 将 utf-8 buffer (Uint8Array) 简单的解码为 string。
+    在流式处理 (buffer 可能不完整) 时，应使用独立的 TextDecoder 实例调用 decode(buffer, { stream: true }) */
+export function decode(buffer) {
+    return decoder.decode(buffer);
+}
+/** 比较两个 buffer 内容是否相同，第二个可以传入 string 自动编码转换后比较，
+    高频调用时建议提前编码 right 并缓存 */
+export function buffer_equals(left, right) {
+    if (typeof right === 'string')
+        right = encode(right);
+    if (left.length !== right.length)
+        return false;
+    for (let i = 0; i < left.length; i++)
+        if (left[i] !== right[i])
+            return false;
+    return true;
+}
+/** 在指定的时间 (milliseconds) 内运行某个任务，超时之后抛出错误或调用 on_timeout
+    - milliseconds: 限时毫秒数
+    - action?: 要等待运行的任务, async function 或 promise
+    - on_timeout?: 超时后调用的函数
+        - 如果传入了 on_timeout 参数: 调用 on_timeout，然后 timeout 函数正常返回 null
+        - 如果没传入 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;
+        let rejected = false;
+        (async () => {
+            await delay(milliseconds);
+            if (!done)
+                if (on_timeout)
+                    try {
+                        await on_timeout();
+                        resolve(null);
+                    }
+                    catch (error) {
+                        if (rejected)
+                            throw error; // 会成为 unhandled rejection
+                        else {
+                            rejected = true;
+                            reject(error);
+                        }
+                    }
+                else {
+                    rejected = true;
+                    reject(error);
+                }
+        })();
+        (async () => {
+            try {
+                resolve(await (typeof action === 'function' ? action() : action));
+            }
+            catch (error) {
+                if (rejected) {
+                    if (print)
+                        console.log(`已超时任务的错误: ${error.message}`);
+                }
+                else {
+                    rejected = true;
+                    reject(error);
+                }
+            }
+            finally {
+                done = true;
+            }
+        })();
+    });
+}
+/** 轮询尝试 action 共 times 次，每次间隔 duration
+    action 返回 trusy 值时认为成功，返回 action 的结果
+    如果次数用尽仍然失败，返回 null */
+export async function poll(duration, times, action) {
+    let break_flag = false;
+    function _break() {
+        break_flag = true;
+    }
+    for (let i = 0; i < times; ++i) {
+        const result = await action(_break);
+        if (result)
+            return result;
+        if (break_flag)
+            break;
+        await delay(duration);
+    }
+    return null;
+}
 /** 模糊过滤字符串列表或对象列表，常用于根据用户输入补全或搜索过滤
     如果有完全匹配的，只返回那一项的数组
     - query: 查询字符串，要求为全小写
@@ -334,17 +450,6 @@ export class Lock {
         });
     }
 }
-export let encoder = new TextEncoder();
-export function encode_into(str, buf) {
-    // 这个是直接用 v8 String::WriteUtf8 最高效的方法了
-    return encoder.encodeInto(str, buf);
-}
-let decoder = new TextDecoder();
-/** 将 utf-8 buffer (Uint8Array) 简单的解码为 string。
-    在流式处理 (buffer 可能不完整) 时，应使用独立的 TextDecoder 实例调用 decode(buffer, { stream: true }) */
-export function decode(buffer) {
-    return decoder.decode(buffer);
-}
 /** 过滤符合 pattern 的行 */
 export function grep(str, pattern) {
     return str.split_lines()

package/utils.d.ts

@@ -1,33 +1,20 @@
 import { Writable, Transform, type Readable, type Duplex, type TransformCallback } from 'stream';
 import util from 'util';
-import type { TimerOptions } from 'timers';
 import './prototype.ts';
+import './platform.ts';
 export * from './utils.common.ts';
 /** `180` 输出字符宽度 */
 export declare const output_width = 180;
 export declare const url_width = 52;
 export declare function set_inspect_options(colors?: boolean): void;
-/** 拼接 TypedArrays 生成一个完整的 Uint8Array */
-export declare function concat(arrays: ArrayBufferView[]): Buffer<ArrayBuffer>;
 export declare function typed_array_to_buffer(view: ArrayBufferView): Buffer<ArrayBufferLike>;
 /** 每天在固定时间执行操作
     - hour: 0 - 23 之间的整数，在这个点执行
     - action */
 export declare function schedule_everyday(hour: number, action: () => Promise<void>): Promise<void>;
 export declare function log_line(): void;
-export declare function delay(milliseconds: number, options?: TimerOptions): Promise<void>;
-/** 在指定的时间 (milliseconds) 内运行某个任务，超时之后抛出错误或调用 on_timeout
-    - milliseconds: 限时毫秒数
-    - action?: 要等待运行的任务, async function 或 promise
-    - on_timeout?: 超时后调用的函数
-        - 如果传入了 on_timeout 参数: 调用 on_timeout，然后 timeout 函数正常返回 null
-        - 如果没传入 on_timeout 参数: 抛出 TimeoutError
-    - print?: 打印已超时任务的错误 */
-export declare function timeout<TReturn>(milliseconds: number, action: Promise<TReturn> | (() => Promise<TReturn>), on_timeout?: () => void | Promise<void>, print?: boolean): Promise<TReturn>;
 export declare function sha256(data: string | Uint8Array): string;
 export declare function sha1(data: string | Uint8Array): string;
-/** 将字符串简单的编码为 utf-8 的 buffer (Uint8Array)。高频使用或者在流式处理时，考虑使用 TextEncoder 的 encodeInto 方法 */
-export declare function encode(str: string): Buffer<ArrayBuffer>;
 export declare function has_chinese(str: string): boolean;
 export declare function escape_line_feed(str: string): string;
 /** util.inspect(obj)
@@ -86,10 +73,3 @@ export declare function consume_stream(stream: Readable, ignore_error?: boolean)
     - reverse?: `false` 在 range 内从后往前生成 */
 export declare function range_to_numbers(range: string, reverse?: boolean): Generator<number, void, unknown>;
 export declare function decode_buffer_hex_string(str: string): string;
-/** 轮询尝试 action 共 times 次，每次间隔 duration
-    action 返回 trusy 值时认为成功，返回 action 的结果
-    如果次数用尽仍然失败，返回 null */
-export declare function poll<TResult>(duration: number, times: number, action: (breaker: () => void) => Promise<TResult>): Promise<TResult>;
-/** 比较两个 buffer 内容是否相同，第二个可以传入 string 自动编码转换后比较，
-    高频调用时建议提前编码 right 并缓存 */
-export declare function buffer_equals(left: Uint8Array, right: Uint8Array | string): boolean;

package/utils.js

@@ -1,9 +1,9 @@
 import { Stream, Writable, Transform } from 'stream';
 import util from 'util';
 import ncrypto from 'crypto';
-import timers from 'timers/promises';
 import "./prototype.js";
-import { assert, decode, defer, TimeoutError } from "./utils.common.js";
+import "./platform.js";
+import { assert, decode, defer, delay } from "./utils.common.js";
 export * from "./utils.common.js";
 /** `180` 输出字符宽度 */
 export const output_width = 180;
@@ -24,20 +24,6 @@ export function set_inspect_options(colors = true) {
     util.inspect.styles.date = 'magenta';
     util.inspect.styles.special = 'white';
 }
-/** 拼接 TypedArrays 生成一个完整的 Uint8Array */
-export function concat(arrays) {
-    let length = 0;
-    for (const a of arrays)
-        length += a.byteLength;
-    let buf = Buffer.allocUnsafe(length);
-    let offset = 0;
-    for (const a of arrays) {
-        const uint8view = new Uint8Array(a.buffer, a.byteOffset, a.byteLength);
-        buf.set(uint8view, offset);
-        offset += uint8view.byteLength;
-    }
-    return buf;
-}
 export function typed_array_to_buffer(view) {
     return Buffer.from(view.buffer, view.byteOffset, view.byteLength);
 }
@@ -62,73 +48,12 @@ export async function schedule_everyday(hour, action) {
 export function log_line() {
     console.log('---');
 }
-export async function delay(milliseconds, options) {
-    return timers.setTimeout(milliseconds, undefined, options);
-}
-/** 在指定的时间 (milliseconds) 内运行某个任务，超时之后抛出错误或调用 on_timeout
-    - milliseconds: 限时毫秒数
-    - action?: 要等待运行的任务, async function 或 promise
-    - on_timeout?: 超时后调用的函数
-        - 如果传入了 on_timeout 参数: 调用 on_timeout，然后 timeout 函数正常返回 null
-        - 如果没传入 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;
-        let rejected = false;
-        (async () => {
-            await delay(milliseconds);
-            if (!done)
-                if (on_timeout)
-                    try {
-                        await on_timeout();
-                        resolve(null);
-                    }
-                    catch (error) {
-                        if (rejected)
-                            throw error; // 会成为 unhandled rejection
-                        else {
-                            rejected = true;
-                            reject(error);
-                        }
-                    }
-                else {
-                    rejected = true;
-                    reject(error);
-                }
-        })();
-        (async () => {
-            try {
-                resolve(await (typeof action === 'function' ? action() : action));
-            }
-            catch (error) {
-                if (rejected) {
-                    if (print)
-                        console.log(`已超时任务的错误: ${error.message}`);
-                }
-                else {
-                    rejected = true;
-                    reject(error);
-                }
-            }
-            finally {
-                done = true;
-            }
-        })();
-    });
-}
 export function sha256(data) {
     return ncrypto.hash('sha256', data);
 }
 export function sha1(data) {
     return ncrypto.hash('sha1', data);
 }
-/** 将字符串简单的编码为 utf-8 的 buffer (Uint8Array)。高频使用或者在流式处理时，考虑使用 TextEncoder 的 encodeInto 方法 */
-export function encode(str) {
-    // 用 Buffer.from 是因为可以利用 buffer pool，避免 encoder.encode 创建大量小且独立的 array buffer
-    return Buffer.from(str);
-}
 export function has_chinese(str) {
     return /[\u4E00-\u9FA5]/.test(str);
 }
@@ -377,34 +302,4 @@ export function decode_buffer_hex_string(str) {
     return decode(Buffer.from(str.split(' ')
         .map(x => parseInt(x, 16))));
 }
-/** 轮询尝试 action 共 times 次，每次间隔 duration
-    action 返回 trusy 值时认为成功，返回 action 的结果
-    如果次数用尽仍然失败，返回 null */
-export async function poll(duration, times, action) {
-    let break_flag = false;
-    function _break() {
-        break_flag = true;
-    }
-    for (let i = 0; i < times; ++i) {
-        const result = await action(_break);
-        if (result)
-            return result;
-        if (break_flag)
-            break;
-        await delay(duration);
-    }
-    return null;
-}
-/** 比较两个 buffer 内容是否相同，第二个可以传入 string 自动编码转换后比较，
-    高频调用时建议提前编码 right 并缓存 */
-export function buffer_equals(left, right) {
-    if (typeof right === 'string')
-        right = encode(right);
-    if (left.length !== right.length)
-        return false;
-    for (let i = 0; i < left.length; i++)
-        if (left[i] !== right[i])
-            return false;
-    return true;
-}
 //# sourceMappingURL=utils.js.map

package/xlint.js

@@ -840,7 +840,7 @@ export const xlint_config = {
         // 用单引号
         '@stylistic/jsx-quotes': ['error', 'prefer-single'],
         // 用单引号
-        '@stylistic/quotes': ['error', 'single', { avoidEscape: true, allowTemplateLiterals: false }],
+        '@stylistic/quotes': ['error', 'single', { avoidEscape: true, allowTemplateLiterals: 'avoidEscape' }],
         // 不要冗余的引号包裹属性
         '@stylistic/quote-props': ['error', 'as-needed', { keywords: false, unnecessary: true }],
         // ------------ 其它

package/io.browser.d.ts

@@ -1,22 +0,0 @@
-import './prototype.browser.ts';
-/** 二进制消息格式, 按 key 的顺序序列化值 */
-export interface Message<TData = any> {
-    /** rpc id: 在 rpc 系统中认为是唯一的。用来在单个 websocket 连接上同时进行多个 rpc 请求。
-        多个相同 id 的 message 组成一个请求流 */
-    id?: number;
-    /** 只在 rpc 发起时指定被调用的 function name，发起时 rpc 时必传 */
-    func?: string;
-    /** 传输的数据
-        - rpc 发起方调用 func 的参数（此时为数组），或者请求流 message 携带的数据
-        - 调用结果（通常为单个返回值）或者响应流的数据，传给请求发起方 */
-    data?: TData;
-    /** 通知对方这里产生的错误，本质上类似 data 也是一种数据，并不代表 rpc 的结束，后续可能继续有 rpc message 交换 */
-    error?: Error;
-    /** 通过这个 flag 主动表明这是发往对方的最后一个 message, 对方可以销毁 handler 了
-        并非强制，可以设置，由双方的函数自己约定 */
-    done?: boolean;
-}
-/** 用这个符号来标识 message 对象 */
-export declare const message_symbol: unique symbol;
-export declare function parse<TReturn>(_buf: Uint8Array): TReturn;
-export declare function pack(obj: any): Uint8Array<ArrayBuffer>;