xshell 1.2.89 → 1.3.1

package/utils.common.js

@@ -1,5 +1,5 @@
 import { t } from "./i18n/instance.js";
-import { ident, is_key_type, noop, not_empty, select, to_snake_case } from "./prototype.common.js";
+import { 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);
@@ -70,14 +70,14 @@ export function sort_keys(obj) {
 }
 /** 比较 1.10.02 这种版本号
     - l, r: 两个版本号字符串
-    - loose?: 宽松模式，允许两个版本号格式（位数）不一致 */
+    - loose?: `false` 宽松模式，允许两个版本号格式（位数）不一致 */
 export function vercmp(l, r, loose = false) {
     const lparts = l.split('.').map(x => Number(x));
     const rparts = r.split('.').map(x => Number(x));
     if (!loose && lparts.length !== rparts.length)
         throw new Error('传入 vercmp 的两个版本号格式不一致');
-    let minlen = Math.min(lparts.length, rparts.length);
-    for (let i = 0; i < minlen; i++) {
+    const minlen = Math.min(lparts.length, rparts.length);
+    for (let i = 0; i < minlen; ++i) {
         const l = lparts[i];
         const r = rparts[i];
         check(!isNaN(l) && !isNaN(r), '传入 vercmp 的版本非法');
@@ -184,9 +184,9 @@ export function buffer_equals(left, right) {
     - milliseconds: 限时毫秒数
     - action?: 要等待运行的任务, async function 或 promise
     - on_timeout?: 超时后调用的函数
-        - 如果传入了 on_timeout 参数: 调用 on_timeout，然后 timeout 函数正常返回 null
-        - 如果没传入 on_timeout 参数: 抛出 TimeoutError
-    - print?: 打印已超时任务的错误 */
+        - 若传: 调用 on_timeout，参数为 TimeoutError，然后 timeout 函数正常返回 null
+        - 若不传: 抛出 TimeoutError
+    - print?: `true` 打印已超时任务的错误 */
 export async function timeout(milliseconds, action, on_timeout, print = true) {
     const error = new TimeoutError();
     return new Promise((resolve, reject) => {
@@ -197,7 +197,7 @@ export async function timeout(milliseconds, action, on_timeout, print = true) {
             if (!done)
                 if (on_timeout)
                     try {
-                        await on_timeout();
+                        await on_timeout(error);
                         resolve(null);
                     }
                     catch (error) {
@@ -252,34 +252,42 @@ export async function poll(duration, times, action) {
     return null;
 }
 /** 模糊过滤字符串列表或对象列表，常用于根据用户输入补全或搜索过滤
-    如果有完全匹配的，只返回那一项的数组
+    如果有完全匹配关键词的，只返回完全匹配关键词的候选项
     - query: 查询字符串，要求为全小写
-    - list: 要过滤的列表
-    - list_lower?: 要过滤的列表对应的全小写字符串列表形式，传入时可复用缓存，加快搜索速度 */
-export function fuzzyfilter(query, list, mapper = ident, list_lower, single_char_startswith = false) {
+    - items: TItem[], 要过滤的列表
+    - keywords: string[][] 每个 item 对应一个全小写字符串的关键词数组，用于实际筛选匹配 */
+export function fuzzyfilter(query, items, keywords, single_char_startswith = false) {
     if (!query)
-        return list;
-    if (is_key_type(mapper))
-        mapper = select(mapper);
-    mapper ??= ident;
-    list_lower ??= list.map(item => mapper(item).toLowerCase());
+        return items;
+    if (!items.length)
+        return [];
     const query_lower = query.toLowerCase();
-    let ifullmatch;
-    if ((ifullmatch = list_lower.indexOf(query_lower)) !== -1)
-        return [list[ifullmatch]];
+    let fullmatches = [];
+    keywords.forEach((words, index) => {
+        if (words.includes(query_lower))
+            fullmatches.push(items[index]);
+    });
+    if (fullmatches.length)
+        return fullmatches;
     if (single_char_startswith && query.length === 1) {
         const c = query[0];
-        return list.filter((_, i) => list_lower[i].startsWith(c));
+        return items.filter((_, i) => keywords[i].some(x => x.startsWith(c)));
     }
-    return list.filter((_, i) => {
-        const str_lower = list_lower[i];
-        let j = 0;
-        for (const c of query_lower) {
-            j = str_lower.indexOf(c, j) + 1;
-            if (!j) // 找不到则 j === 0
-                return false;
+    return items.filter((_, i) => {
+        for (const str_lower of keywords[i]) {
+            let j = 0;
+            let not_found = false;
+            for (const c of query_lower) {
+                j = str_lower.indexOf(c, j) + 1;
+                if (!j) { // 找不到则 j === 0
+                    not_found = true;
+                    break;
+                }
+            }
+            if (!not_found)
+                return true;
         }
-        return true;
+        return false;
     });
 }
 export function get(obj, keypath) {
@@ -326,16 +334,16 @@ export const date_format = 'YYYY.MM.DD';
 /** 默认时间格式 */
 export const time_format = 'HH:mm:ss';
 export class Timer {
-    started = new Date().getTime();
-    ended;
+    started = Date.now();
+    ended = 0;
     /** 停止秒表，保存读数 */
     stop() {
-        this.ended = new Date().getTime();
+        this.ended = Date.now();
     }
     /** 如果秒表未停止，获取当前秒表读数；
         如果秒表已停止，获取停止时的秒表读数; */
     get() {
-        return (this.ended || new Date().getTime()) - this.started;
+        return (this.ended || Date.now()) - this.started;
     }
     /** 获取时间表示字符串，如 1.2 s
         - parenthesis?: `true` 字符串前后加上括号，如 (1.2 s) */
@@ -351,8 +359,8 @@ export class Timer {
     }
     /** 重置 started */
     reset() {
-        this.started = new Date().getTime();
-        this.ended = null;
+        this.started = Date.now();
+        this.ended = 0;
     }
     get_and_reset() {
         const result = this.get();
@@ -388,6 +396,33 @@ export function defer(initial) {
             reject: noop
         });
 }
+/** 有 settled 状态的 defer */
+// eslint-disable-next-line @typescript-eslint/promise-function-async
+export function defer2(initial) {
+    if (initial === undefined) {
+        let settled = false;
+        let { promise, resolve, reject } = Promise.withResolvers();
+        return Object.assign(promise, {
+            resolve(value) {
+                settled = true;
+                resolve(value);
+            },
+            reject(error) {
+                settled = true;
+                reject(error);
+            },
+            get settled() {
+                return settled;
+            }
+        });
+    }
+    else
+        return Object.assign(Promise.resolve(initial), {
+            resolve: noop,
+            reject: noop,
+            settled: true
+        });
+}
 /** @example
     let lock = new Lock(redis)
     
@@ -522,4 +557,36 @@ export function tomorrow(date) {
 export function to_csv_field(str) {
     return /[,"\n\r]/.test(str) ? str.replaceAll('"', '""').quote('double') : str;
 }
+/** 设置 error.message 同时更新 error.stack */
+export function set_error_message(error, message) {
+    error.message = message;
+    error.stack = `${error.name}: ${message}\n` +
+        error.stack.slice_from('\n', { optional: true });
+    return error;
+}
+/** 比较两个数组中的元素完全相同，数组元素用引用比较 */
+export function array_equals(a, b) {
+    if (!a && !b)
+        return true;
+    if (a && !b || !a && b)
+        return false;
+    return a.every((x, i) => x === b[i]);
+}
+export function nowstr(with_date = false) {
+    const date = new Date();
+    return with_date ? date.to_str() : date.to_time_str();
+}
+/** 面向对象的 timeout, callback 在后的 timeout */
+export function set_timeout(delay, callback) {
+    let ret = {
+        ref: setTimeout(callback, delay),
+        clear() {
+            if (!ret.ref)
+                return;
+            clearTimeout(ret.ref);
+            ret.ref = null;
+        }
+    };
+    return ret;
+}
 //# sourceMappingURL=utils.common.js.map

package/utils.d.ts

@@ -1,5 +1,5 @@
-import { Writable, Transform, type Readable, type Duplex, type TransformCallback } from 'stream';
-import util from 'util';
+import { Writable, Transform, type Readable, type Duplex, type TransformCallback } from 'node:stream';
+import util from 'node:util';
 import './prototype.ts';
 import './platform.ts';
 export * from './utils.common.ts';

package/utils.js

@@ -1,6 +1,6 @@
-import { Stream, Writable, Transform } from 'stream';
-import util from 'util';
-import ncrypto from 'crypto';
+import { Stream, Writable, Transform } from 'node:stream';
+import util from 'node:util';
+import ncrypto from 'node:crypto';
 import "./prototype.js";
 import "./platform.js";
 import { assert, decode, defer, delay } from "./utils.common.js";
@@ -40,7 +40,13 @@ export async function schedule_everyday(hour, action) {
     // 等时间到
     await delay(target.getTime() - now.getTime());
     for (;;) {
-        await action();
+        try {
+            await action();
+        }
+        catch (error) {
+            // 往上抛没什么意义，打印个日志算了
+            console.error(error);
+        }
         // 等一天
         await delay(1000 * 60 * 60 * 24);
     }

package/i18n/utils.d.ts

@@ -1 +0,0 @@
-export declare function try_load_dict(fp_dict: string): Promise<any>;

package/i18n/utils.js

@@ -1,11 +0,0 @@
-import { fread_json } from "../file.js";
-export async function try_load_dict(fp_dict) {
-    try {
-        return await fread_json(fp_dict, { print: false });
-    }
-    catch {
-        // console.error('未找到或解析错误，跳过加载：' + modpath)
-        return {};
-    }
-}
-//# sourceMappingURL=utils.js.map