xshell 1.1.9 → 1.1.10

package/prototype.d.ts

@@ -71,8 +71,7 @@ declare global {
         surround_tag(this: string, tag_name: string): string;
         to_lf(this: string): string;
         /** 'xxx'.replace(/pattern/g, '')
-            如果 pattern 是 string 则在创建 RegExp 时自动加上 flags (默认 'g'), 否则忽略 flags
-        */
+            如果 pattern 是 string 则在创建 RegExp 时自动加上 flags (默认 'g'), 否则忽略 flags */
         rm(this: string, pattern: string | RegExp, flags?: string): string;
         readonly red: string;
         readonly red_: string;
@@ -127,17 +126,25 @@ declare global {
         slice_to(this: string, search: string, options?: SliceOptions): string;
         /** 等价于 .endsWith('/') */
         isdir: boolean;
-        /** 以 `/` 分割的路径，可能以 / 结尾 */
+        /** 转换为以 `/` 分割的路径，可能以 / 结尾 */
         fp: string;
-        /** 以 `/` 分割的文件夹路径，一定以 / 结尾 */
+        /** 转换为以 `/` 分割的文件夹路径，一定以 / 结尾 */
         fpd: string;
-        /** 父文件夹路径 (path.dirname)，一定以 `/` 结尾 */
+        /** 父文件夹路径，一定以 `/` 结尾，或为空
+            特殊情况:
+            - '/'.fdir === ''
+            - 'D:/'.fdir === '' */
         fdir: string;
-        /** 文件名 (path.basename 的结果), 保留结尾的 /，如:
+        /** 文件或文件夹名, 保留结尾的 /
+            常规情况:
             - D:/0/aaa.txt -> aaa.txt
-            - D:/aaa/ -> aaa/ */
+            - D:/aaa/ -> aaa/
+            特殊情况:
+            - '/'.fname === '/'
+            - 'D:/'.fname === 'D:/' */
         fname: string;
-        /** .txt */
+        /** 文件后缀名，不带点，如: txt, zip，没有后缀时返回空字符串
+            特殊情况: .aaa 的 fext 为 '' */
         fext: string;
         to_backslash(this: string): string;
     }
@@ -173,15 +180,15 @@ declare global {
         log(this: string[], limit?: number): void;
         indent(this: string[], width?: number, c?: string): string[];
         indent2to4(this: string[]): string[];
-        /** 对数组中所有元素求和 (+), 返回结果，可传入 selector 选择某个属性，或者计算出某个值，用作求和 */
-        sum<TReturn = T>(this: T[], selector?: keyof T | KeySelector<T>): TReturn;
-        /** 查找数组中最大的元素，可传入 selector 选择某个属性，或者计算出某个值，用作大小比较 */
-        max(this: T[], selector?: keyof T | KeySelector<T>): T;
-        /** 查找数组中最小的元素，可传入 selector 选择某个属性，或者计算出某个值，用作大小比较 */
-        min(this: T[], selector?: keyof T | KeySelector<T>): T;
-        /** 去除重复元素（可按 selector 去重），重复值保留最后出现的那个
-            - selector?: 可以是 key (string, number, symbol) 或 (obj: any) => any */
-        unique(this: T[], selector?: keyof T | KeySelector<T>): T[];
+        /** 对数组中所有元素求和 (+), 返回结果，可传入 mapper 计算出某个值，用作求和 */
+        sum<TReturn = T>(this: T[], mapper?: keyof T | Mapper<T>): TReturn;
+        /** 查找数组中最大的元素，可传入 mapper 计算出某个值，用作大小比较 */
+        max(this: T[], mapper?: keyof T | Mapper<T>): T;
+        /** 查找数组中最小的元素，可传入 mapper 计算出某个值，用作大小比较 */
+        min(this: T[], mapper?: keyof T | Mapper<T>): T;
+        /** 去除重复元素（可按 mapper 选择或计算某个值来去重），重复值保留最后出现的那个
+            - mapper?: 可以是 key (string, number, symbol) 或 (obj: any) => any */
+        unique(this: T[], mapper?: keyof T | Mapper<T>): T[];
         /**
             - trim_line?: `true`
             - rm_empty_lines?: `true`
@@ -209,7 +216,7 @@ declare global {
         toJSON(this: Error): string;
     }
     interface Set<T> {
-        map<TResult>(mapfn: (value: T, index: number) => TResult): TResult[];
+        map<TResult>(mapper: (value: T, index: number) => TResult): TResult[];
     }
 }
 interface SliceOptions {
@@ -219,8 +226,8 @@ interface SliceOptions {
 export declare const emoji_regex: RegExp;
 export declare const noop: () => void;
 export declare const ident: <T>(x: T) => T;
-export declare const build_selector: <TObj>(key: keyof TObj) => (obj: TObj) => TObj[keyof TObj];
-export type KeySelector<TObj = any, TKey extends keyof TObj = keyof TObj> = (key: TObj) => TObj[TKey];
+export declare const build_mapper: <TObj>(key: keyof TObj) => (obj: TObj) => TObj[keyof TObj];
+export type Mapper<TObj = any, TKey extends keyof TObj = keyof TObj> = (obj: TObj) => TObj[TKey];
 /** value 不为 null 或 undefined */
 export declare const not_empty: (value: any) => boolean;
 export declare const empty: (value: any) => boolean;

package/prototype.js

@@ -2,11 +2,10 @@ import util from 'util';
 import EmojiRegex from 'emoji-regex';
 export const emoji_regex = EmojiRegex();
 import strip_ansi from 'strip-ansi';
-import { to_fp, dirname, basename, extname } from "./path.js";
 import { t } from "./i18n/instance.js";
 export const noop = () => { };
 export const ident = (x) => x;
-export const build_selector = (key) => (obj) => obj[key];
+export const build_mapper = (key) => (obj) => obj[key];
 /** value 不为 null 或 undefined */
 export const not_empty = (value) => value !== null && value !== undefined;
 export const empty = (value) => value === undefined || value === null;
@@ -247,9 +246,6 @@ if (!globalThis.my_prototype_defined) {
             to_lf() {
                 return this.replace(/\r\n/g, '\n');
             },
-            to_crlf() {
-                return this.replace(/\n/g, '\r\n');
-            },
             rm(pattern, flags = 'g') {
                 if (typeof pattern === 'string')
                     pattern = new RegExp(pattern, flags);
@@ -371,28 +367,47 @@ if (!globalThis.my_prototype_defined) {
                 return this.endsWith('/');
             },
             fp() {
-                return to_fp(this);
+                if (!this)
+                    return this;
+                const fp = this.replaceAll('\\', '/');
+                // 转换小写盘符开头的路径
+                return fp[1] === ':' && 'a' <= fp[0] && fp[0] <= 'z'
+                    ? fp[0].toUpperCase() + fp.slice(1)
+                    : fp;
             },
             fpd() {
-                const fp = to_fp(this);
+                const { fp } = this;
                 return fp.endsWith('/') ? fp : `${fp}/`;
             },
             fdir() {
-                const fpd = dirname(this);
-                // 有可能 fpd 是 '/'
-                return fpd.endsWith('/') ? fpd : `${fpd}/`;
+                return this.strip_end(this.fname);
             },
             fname() {
-                return `${basename(this)}${this.endsWith('/') ? '/' : ''}`;
+                const ilast = this.lastIndexOf('/');
+                if (ilast === -1)
+                    return this; // 没有斜杠时返回整个字符串
+                // 以斜杠结尾的情况
+                if (ilast === this.length - 1) {
+                    const iprev = this.lastIndexOf('/', ilast - 1);
+                    return iprev === -1
+                        ? this // 只有一个斜杠且在末尾
+                        : this.slice(iprev + 1);
+                }
+                // 返回最后一个斜杠后的内容
+                return this.slice(ilast + 1);
             },
             fext() {
-                return extname(this);
-            },
+                const { fname } = this;
+                const index = fname.lastIndexOf('.');
+                return index <= 0
+                    ? ''
+                    : fname.slice(index + 1);
+            }
         }),
         ...to_method_property_descriptors({
             to_backslash() {
                 return this.replaceAll('/', '\\');
-            },
+            }
         })
     });
     // ------------------------------------ Date.prototype
@@ -449,10 +464,9 @@ if (!globalThis.my_prototype_defined) {
         return String(hour).padStart(2, '0') + splitter +
             String(date.getMinutes()).padStart(2, '0') + splitter +
             String(date.getSeconds()).padStart(2, '0') +
-            (ms ?
-                '.' + String(date.getMilliseconds()).padStart(3, '0')
-                :
-                    '');
+            (ms
+                ? '.' + String(date.getMilliseconds()).padStart(3, '0')
+                : '');
     }
     // ------------------------------------ Number.prototype
     Object.defineProperties(Number.prototype, to_method_property_descriptors({
@@ -528,27 +542,27 @@ if (!globalThis.my_prototype_defined) {
                 return this.split_indents()
                     .map(line => ' '.repeat(line.indent * 2) + line.text);
             },
-            sum(selector) {
+            sum(mapper) {
                 if (!this.length)
                     return undefined;
                 // 快捷路径
                 const first = this[0];
-                if ((typeof first === 'number' || typeof first === 'bigint') && !selector)
+                if ((typeof first === 'number' || typeof first === 'bigint') && !mapper)
                     return this.reduce((acc, x) => acc + x, first);
-                if (is_key_type(selector))
-                    selector = build_selector(selector);
-                selector ??= ident;
-                return this.reduce((acc, x) => acc + selector(x), selector(first));
+                if (is_key_type(mapper))
+                    mapper = build_mapper(mapper);
+                mapper ??= ident;
+                return this.reduce((acc, x) => acc + mapper(x), mapper(first));
             },
-            max(selector = ident) {
+            max(mapper = ident) {
                 if (!this.length)
                     return undefined;
-                if (is_key_type(selector))
-                    selector = build_selector(selector);
-                let max = selector(this[0]);
+                if (is_key_type(mapper))
+                    mapper = build_mapper(mapper);
+                let max = mapper(this[0]);
                 let imax = 0;
                 for (let i = 0; i < this.length; i++) {
-                    const value = selector(this[i]);
+                    const value = mapper(this[i]);
                     if (value > max) {
                         max = value;
                         imax = i;
@@ -556,15 +570,15 @@ if (!globalThis.my_prototype_defined) {
                 }
                 return this[imax];
             },
-            min(selector = ident) {
+            min(mapper = ident) {
                 if (!this.length)
                     return undefined;
-                if (is_key_type(selector))
-                    selector = build_selector(selector);
-                let min = selector(this[0]);
+                if (is_key_type(mapper))
+                    mapper = build_mapper(mapper);
+                let min = mapper(this[0]);
                 let imin = 0;
                 for (let i = 0; i < this.length; i++) {
-                    const value = selector(this[i]);
+                    const value = mapper(this[i]);
                     if (value < min) {
                         min = value;
                         imin = i;
@@ -572,14 +586,14 @@ if (!globalThis.my_prototype_defined) {
                 }
                 return this[imin];
             },
-            unique(selector) {
-                if (!selector)
+            unique(mapper) {
+                if (!mapper)
                     return [...new Set(this)];
-                if (is_key_type(selector))
-                    selector = build_selector(selector);
+                if (is_key_type(mapper))
+                    mapper = build_mapper(mapper);
                 let map = new Map();
                 for (const x of this)
-                    map.set(selector(x), x);
+                    map.set(mapper(x), x);
                 return [...map.values()];
             },
             join_lines(append = true) {

package/server.d.ts

@@ -3,6 +3,15 @@ import { type Http2SecureServer, type IncomingHttpHeaders as IncomingHttp2Header
 import type { Duplex } from 'stream';
 import type { WebSocketServer } from 'ws';
 import { default as Koa, type Context, type Next } from 'koa';
+import { Remote, type RequestOptions, type RawResponse } from './net.ts';
+declare module 'http' {
+    interface IncomingMessage {
+        body?: Buffer;
+    }
+    interface ServerResponse {
+        body?: Buffer;
+    }
+}
 declare module 'koa' {
     interface Request {
         /** 经过 decodeURIComponent 后，在路径重写之前的路径 */
@@ -13,15 +22,6 @@ declare module 'koa' {
         compress: boolean;
     }
 }
-import { Remote, type RequestOptions, type RawResponse } from './net.ts';
-declare module 'http' {
-    interface IncomingMessage {
-        body?: Buffer;
-    }
-    interface ServerResponse {
-        body?: Buffer;
-    }
-}
 export declare class Server {
     /** proxy 时需要丢弃的 resposne headers */
     static drop_response_headers: Set<string>;
@@ -33,9 +33,10 @@ export declare class Server {
     };
     /** sea 下最后修改时间，用于 http 资源缓存 */
     last_modified_str?: string;
-    js_exts: Set<string>;
-    empty_body_statuses: Set<number>;
-    empty_body_methods: Set<string>;
+    static js_exts: Set<string>;
+    static logger_ignore_fexts: Set<string>;
+    static empty_body_statuses: Set<number>;
+    static empty_body_methods: Set<string>;
     app: Koa;
     handler: ReturnType<Koa['callback']>;
     /** 启用 http server */

package/server.js

@@ -37,9 +37,10 @@ export class Server {
     };
     /** sea 下最后修改时间，用于 http 资源缓存 */
     last_modified_str;
-    js_exts = new Set(['.js', '.mjs', '.cjs']);
-    empty_body_statuses = new Set([304, 204, 205]);
-    empty_body_methods = new Set(['HEAD', 'OPTIONS']);
+    static js_exts = new Set(['.js', '.mjs', '.cjs']);
+    static logger_ignore_fexts = new Set(['.js', '.css', '.map', '.png', '.jpg', '.svg', '.ico', '.json', '.woff2', '.ttf', '.php']);
+    static empty_body_statuses = new Set([304, 204, 205]);
+    static empty_body_methods = new Set(['HEAD', 'OPTIONS']);
     app;
     handler;
     /** 启用 http server */
@@ -384,6 +385,8 @@ export class Server {
         const { request } = ctx;
         const { query: queries, body, path, _path, protocol, host, req: { httpVersion: http_version }, ip, headers, } = request;
         let { method } = request;
+        if (Server.logger_ignore_fexts.has(path.fext))
+            return;
         let s = '';
         // 时间
         s += `${this.log_date ? new Date().to_str() : new Date().to_time_str()}  `;
@@ -522,7 +525,7 @@ export class Server {
                 // 关联了 response_.body 到 res 的 finish 事件，(koa/response.js#set body() 中 onFinish(res, destroy.bind(null, response_.body))
                 // 会让 response_.body 这个 UndiciBodyReadable 被提前 finish，而此时
                 // 流还没 emit end, 会触发错误 RequestAbortedError [AbortError]: Request aborted
-                if (this.empty_body_statuses.has(response_.status) || this.empty_body_methods.has(method))
+                if (Server.empty_body_statuses.has(response_.status) || Server.empty_body_methods.has(method))
                     consume_stream(response_.body, true);
                 else
                     response.body = response_.body;
@@ -652,8 +655,9 @@ export class Server {
             response.set('content-disposition', `attachment; filename="${encodeURIComponent(fp.fname)}"`);
         if (!response.get('content-type')) {
             const { fext } = fp;
-            response.set('content-type', (this.js_exts.has(fext) ? 'text/javascript; chatset=utf-8' : get_content_type(fext))
-                || 'application/octet-stream');
+            response.set('content-type', (Server.js_exts.has(fext)
+                ? 'text/javascript; chatset=utf-8'
+                : get_content_type(`file.${fext}`) || 'application/octet-stream'));
         }
         const modified_since_str = request.get('if-modified-since');
         if ((method === 'GET' || method === 'HEAD') && modified_since_str === last_modified_str) {

package/storage.d.ts

@@ -1,12 +1,12 @@
 export declare let storage: {
     /** 通过 key 获取字符串类型的值，不存在时返回空字符串 ('') */
-    getstr(key: string): string;
+    getstr<TString extends string = string>(key: string): TString;
     /** 将字符串类型的值保存到 key */
     setstr(key: string, value?: string): void;
     /** 根据 key 获取 JSON 类型的值，不存在时返回通过第二个参数传入的默认值，默认为 null */
     get<TValue = any>(key: string, _default?: TValue): TValue;
-    /** 保存 JSON 类型的值到 key */
-    set(key: string, value: any): void;
+    /** 保存 JSON 类型的值到 key, 并返回 value */
+    set<TValue>(key: string, value: TValue): TValue;
     list(): string[];
     delete(key: string): void;
 };

package/storage.js

@@ -1,7 +1,7 @@
 export let storage = {
     /** 通过 key 获取字符串类型的值，不存在时返回空字符串 ('') */
     getstr(key) {
-        return localStorage.getItem(key) || '';
+        return (localStorage.getItem(key) || '');
     },
     /** 将字符串类型的值保存到 key */
     setstr(key, value = '') {
@@ -14,9 +14,10 @@ export let storage = {
             ? _default
             : JSON.parse(strvalue);
     },
-    /** 保存 JSON 类型的值到 key */
+    /** 保存 JSON 类型的值到 key, 并返回 value */
     set(key, value) {
         localStorage.setItem(key, JSON.stringify(value));
+        return value;
     },
     list() {
         return Object.keys(localStorage);

package/utils.browser.d.ts

@@ -1,16 +1,16 @@
-import { type KeySelector } from './prototype.browser.ts';
-export declare function assert(assertion: any, message?: string): never | void;
+import { type Mapper } from './prototype.browser.ts';
+export declare function assert<T>(assertion: T, message?: string): T;
 /** 做参数校验，逻辑检查 */
-export declare function check(condition: any, message?: string): never | void;
+export declare function check<T>(condition: T, message?: string): T;
 /** 通过 console.log 打印对象并返回
     @example
     log('label', obj)
     log(obj) */
 export declare function log<TObj>(obj: TObj): TObj;
 export declare function log<TObj>(label: string, obj: TObj): TObj;
-/** 数组或 iterable 去重（可按 selector 去重），重复值保留最后出现的那个
-    - selector?: 可以是 key (string, number, symbol) 或 (obj: any) => any */
-export declare function unique<TObj>(iterable: TObj[] | Iterable<TObj>, selector?: keyof TObj | KeySelector<TObj>): TObj[];
+/** 数组或 iterable 去重（可按 mapper 选择或计算某个值来去重），重复值保留最后出现的那个
+    - mapper?: 可以是 key (string, number, symbol) 或 (obj: any) => any */
+export declare function unique<TObj>(iterable: TObj[] | Iterable<TObj>, mapper?: keyof TObj | Mapper<TObj>): TObj[];
 /** 生成 0, 1, ..., n - 1 (不包括 n) 的数组，支持传入 generator 函数，通过 index 生成各个元素
     @example seq(10, i => `item-${i}`) */
 export declare function seq<T = number>(n: number, generator?: (index: number) => T): T[];
@@ -79,11 +79,16 @@ export declare function encode(str: string): Uint8Array<ArrayBufferLike>;
     在流式处理 (buffer 可能不完整) 时，应使用独立的 TextDecoder 实例调用 decode(buffer, { stream: true }) */
 export declare function decode(buffer: Uint8Array): string;
 /** 字符串字典序比较 */
-export declare function strcmp(l: string, r: string): 0 | 1 | -1;
+export declare function strcmp(l: string, r: string): 1 | 0 | -1;
 /** 比较 1.10.02 这种版本号
     - l, r: 两个版本号字符串
     - loose?: 宽松模式，允许两个版本号格式（位数）不一致 */
 export declare function vercmp(l: string, r: string, loose?: boolean): number;
+/** 模糊过滤字符串列表或对象列表，常用于根据用户输入补全或搜索过滤
+    - query: 查询字符串，要求为全小写
+    - list: 要过滤的列表
+    - list_lower?: 要过滤的列表对应的全小写字符串列表形式，传入时可复用缓存，加快搜索速度 */
+export declare function fuzzyfilter<TItem = string>(query: string, list: TItem[], mapper?: keyof TItem | Mapper<TItem>, list_lower?: string[], single_char_startswith?: boolean): TItem[];
 export declare function get<TReturn = any>(obj: any, keypath: string): TReturn;
 export declare function global_get<TReturn = any>(keypath: string): TReturn;
 export declare function invoke<TReturn = any>(obj: any, funcpath: string, args: any[]): TReturn;

package/utils.browser.js

@@ -1,17 +1,19 @@
-import { is_key_type, build_selector, not_empty } from "./prototype.browser.js";
+import { is_key_type, build_mapper, not_empty, ident } from "./prototype.browser.js";
 import { t } from "./i18n/instance.js";
 export function assert(assertion, message) {
     if (!assertion) {
         debugger;
-        throw new Error(`断言失败: ${message ? `${message}: ` : ''}`);
+        throw new Error(`${t('断言失败')}: ${message ? `${message}: ` : ''}`);
     }
+    return assertion;
 }
 /** 做参数校验，逻辑检查 */
 export function check(condition, message) {
     if (!condition) {
         debugger;
-        throw new Error(message || '检查失败');
+        throw new Error(message || t('检查失败'));
     }
+    return condition;
 }
 export function log(...args) {
     if (args.length === 2) {
@@ -25,16 +27,16 @@ export function log(...args) {
         return obj;
     }
 }
-/** 数组或 iterable 去重（可按 selector 去重），重复值保留最后出现的那个
-    - selector?: 可以是 key (string, number, symbol) 或 (obj: any) => any */
-export function unique(iterable, selector) {
-    if (!selector)
+/** 数组或 iterable 去重（可按 mapper 选择或计算某个值来去重），重复值保留最后出现的那个
+    - mapper?: 可以是 key (string, number, symbol) 或 (obj: any) => any */
+export function unique(iterable, mapper) {
+    if (!mapper)
         return [...new Set(iterable)];
-    if (is_key_type(selector))
-        selector = build_selector(selector);
+    if (is_key_type(mapper))
+        mapper = build_mapper(mapper);
     let map = new Map();
     for (const x of iterable)
-        map.set(selector(x), x);
+        map.set(mapper(x), x);
     return [...map.values()];
 }
 /** 生成 0, 1, ..., n - 1 (不包括 n) 的数组，支持传入 generator 函数，通过 index 生成各个元素
@@ -260,6 +262,33 @@ export function vercmp(l, r, loose = false) {
     // loose 下按短的优先，否则应该一样，为 0
     return lparts.length - rparts.length;
 }
+/** 模糊过滤字符串列表或对象列表，常用于根据用户输入补全或搜索过滤
+    - query: 查询字符串，要求为全小写
+    - list: 要过滤的列表
+    - list_lower?: 要过滤的列表对应的全小写字符串列表形式，传入时可复用缓存，加快搜索速度 */
+export function fuzzyfilter(query, list, mapper = ident, list_lower, single_char_startswith = false) {
+    if (!query)
+        return list;
+    if (is_key_type(mapper))
+        mapper = build_mapper(mapper);
+    mapper ??= ident;
+    list_lower ??= list.map(item => mapper(item).toLowerCase());
+    if (single_char_startswith && query.length === 1) {
+        const c = query[0];
+        return list.filter((_, i) => list_lower[i].startsWith(c));
+    }
+    const query_lower = query.toLowerCase();
+    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 true;
+    });
+}
 export function get(obj, keypath) {
     let obj_ = obj;
     for (const key of keypath.split('.'))

package/utils.d.ts

@@ -2,22 +2,22 @@ import { Writable, Transform, type Readable, type Duplex, type TransformCallback
 import util from 'util';
 import type { TimerOptions } from 'timers';
 import type Vinyl from 'vinyl';
-import { type KeySelector } from './prototype.ts';
+import { type Mapper } from './prototype.ts';
 /** `230` term 字符宽度 （实际上有 240） */
 export declare const output_width = 230;
 export declare function set_inspect_options(colors?: boolean): void;
-export declare function assert(assertion: any, message?: string): never | void;
+export declare function assert<T>(assertion: T, message?: string): T;
 /** 做参数校验，逻辑检查 */
-export declare function check(condition: any, message?: string): never | void;
+export declare function check<T>(condition: T, message?: string): T;
 /** 通过 console.log 打印对象并返回
     @example
     log('label', obj)
     log(obj) */
 export declare function log<TObj>(obj: TObj): TObj;
 export declare function log<TObj>(label: string, obj: TObj): TObj;
-/** 数组或 iterable 去重（可按 selector 去重），重复值保留最后出现的那个
-    - selector?: 可以是 key (string, number, symbol) 或 (obj: any) => any */
-export declare function unique<TObj>(iterable: TObj[] | Iterable<TObj>, selector?: keyof TObj | KeySelector<TObj>): TObj[];
+/** 数组或 iterable 去重（可按 mapper 选择或计算某个值来去重），重复值保留最后出现的那个
+    - mapper?: 可以是 key (string, number, symbol) 或 (obj: any) => any */
+export declare function unique<TObj>(iterable: TObj[] | Iterable<TObj>, mapper?: keyof TObj | Mapper<TObj>): TObj[];
 /** 生成 0, 1, ..., n - 1 (不包括 n) 的数组，支持传入 generator 函数，通过 index 生成各个元素
     @example seq(10, i => `item-${i}`) */
 export declare function seq<T = number>(n: number, generator?: (index: number) => T): T[];
@@ -40,11 +40,16 @@ export declare function filter_values<TObj extends Record<string, any>>(obj: TOb
 /** 忽略对象中的 keys, 返回新对象 */
 export declare function omit<TObj>(obj: TObj, omit_keys: string[]): TObj;
 /** 字符串字典序比较 */
-export declare function strcmp(l: string, r: string): 0 | 1 | -1;
+export declare function strcmp(l: string, r: string): 1 | 0 | -1;
 /** 比较 1.10.02 这种版本号
     - l, r: 两个版本号字符串
     - loose?: 宽松模式，允许两个版本号格式（位数）不一致 */
 export declare function vercmp(l: string, r: string, loose?: boolean): number;
+/** 模糊过滤字符串列表或对象列表，常用于根据用户输入补全或搜索过滤
+    - query: 查询字符串，要求为全小写
+    - list: 要过滤的列表
+    - list_lower?: 要过滤的列表对应的全小写字符串列表形式，传入时可复用缓存，加快搜索速度 */
+export declare function fuzzyfilter<TItem = string>(query: string, list: TItem[], mapper?: keyof TItem | Mapper<TItem>, list_lower?: string[], single_char_startswith?: boolean): TItem[];
 export declare function get<TReturn = any>(obj: any, keypath: string): TReturn;
 export declare function global_get<TReturn = any>(keypath: string): TReturn;
 export declare function invoke<TReturn = any>(obj: any, funcpath: string, args: any[]): TReturn;

package/utils.js

@@ -2,7 +2,7 @@ import { Stream, Writable, Transform } from 'stream';
 import util from 'util';
 import timers from 'timers/promises';
 import { t } from "./i18n/instance.js";
-import { build_selector, not_empty, is_key_type, noop } from "./prototype.js";
+import { build_mapper, not_empty, is_key_type, noop, ident } from "./prototype.js";
 /** `230` term 字符宽度 （实际上有 240） */
 export const output_width = 230;
 export function set_inspect_options(colors = true) {
@@ -26,6 +26,7 @@ export function assert(assertion, message) {
         debugger;
         throw new Error(`${t('断言失败')}: ${message ? `${message}: ` : ''}`);
     }
+    return assertion;
 }
 /** 做参数校验，逻辑检查 */
 export function check(condition, message) {
@@ -33,6 +34,7 @@ export function check(condition, message) {
         debugger;
         throw new Error(message || t('检查失败'));
     }
+    return condition;
 }
 export function log(...args) {
     if (args.length === 2) {
@@ -46,16 +48,16 @@ export function log(...args) {
         return obj;
     }
 }
-/** 数组或 iterable 去重（可按 selector 去重），重复值保留最后出现的那个
-    - selector?: 可以是 key (string, number, symbol) 或 (obj: any) => any */
-export function unique(iterable, selector) {
-    if (!selector)
+/** 数组或 iterable 去重（可按 mapper 选择或计算某个值来去重），重复值保留最后出现的那个
+    - mapper?: 可以是 key (string, number, symbol) 或 (obj: any) => any */
+export function unique(iterable, mapper) {
+    if (!mapper)
         return [...new Set(iterable)];
-    if (is_key_type(selector))
-        selector = build_selector(selector);
+    if (is_key_type(mapper))
+        mapper = build_mapper(mapper);
     let map = new Map();
     for (const x of iterable)
-        map.set(selector(x), x);
+        map.set(mapper(x), x);
     return [...map.values()];
 }
 /** 生成 0, 1, ..., n - 1 (不包括 n) 的数组，支持传入 generator 函数，通过 index 生成各个元素
@@ -130,6 +132,33 @@ export function vercmp(l, r, loose = false) {
     // loose 下按短的优先，否则应该一样，为 0
     return lparts.length - rparts.length;
 }
+/** 模糊过滤字符串列表或对象列表，常用于根据用户输入补全或搜索过滤
+    - query: 查询字符串，要求为全小写
+    - list: 要过滤的列表
+    - list_lower?: 要过滤的列表对应的全小写字符串列表形式，传入时可复用缓存，加快搜索速度 */
+export function fuzzyfilter(query, list, mapper = ident, list_lower, single_char_startswith = false) {
+    if (!query)
+        return list;
+    if (is_key_type(mapper))
+        mapper = build_mapper(mapper);
+    mapper ??= ident;
+    list_lower ??= list.map(item => mapper(item).toLowerCase());
+    if (single_char_startswith && query.length === 1) {
+        const c = query[0];
+        return list.filter((_, i) => list_lower[i].startsWith(c));
+    }
+    const query_lower = query.toLowerCase();
+    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 true;
+    });
+}
 export function get(obj, keypath) {
     let obj_ = obj;
     for (const key of keypath.split('.'))