xshell 1.1.8 → 1.1.10

package/server.d.ts

@@ -2,7 +2,16 @@ import { type Server as HttpServer, type IncomingHttpHeaders, type IncomingMessa
 import { type Http2SecureServer, type IncomingHttpHeaders as IncomingHttp2Headers } from 'http2';
 import type { Duplex } from 'stream';
 import type { WebSocketServer } from 'ws';
-import type { default as Koa, Context, Next } from 'koa';
+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,16 +22,6 @@ declare module 'koa' {
         compress: boolean;
     }
 }
-import type { UAParser } from 'ua-parser-js';
-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>;
@@ -34,10 +33,10 @@ export declare class Server {
     };
     /** sea 下最后修改时间，用于 http 资源缓存 */
     last_modified_str?: string;
-    UAParser: typeof UAParser;
-    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

@@ -6,6 +6,12 @@ import fs from 'fs';
 import { buffer as stream_to_buffer } from 'stream/consumers';
 import util from 'util';
 import node_sea from 'node:sea';
+import { default as Koa } from 'koa';
+import KoaCors from '@koa/cors';
+import KoaCompress from 'koa-compress';
+import { UAParser } from 'ua-parser-js';
+import resolve_safely from 'resolve-path';
+import { contentType as get_content_type } from 'mime-types';
 // --- my libs
 import { t } from "./i18n/instance.js";
 import { request as _request, Remote } from "./net.js";
@@ -31,10 +37,10 @@ export class Server {
     };
     /** sea 下最后修改时间，用于 http 资源缓存 */
     last_modified_str;
-    UAParser;
-    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 */
@@ -93,14 +99,9 @@ export class Server {
     }
     /** start http server and listen */
     async start() {
-        const { default: Koa } = await import('koa');
-        const { default: KoaCors } = await import('@koa/cors');
-        const { default: KoaCompress } = await import('koa-compress');
         if (sea)
             this.last_modified_str = (await fstat(exe_nodejs))
                 .mtime.toUTCString();
-        const { UAParser } = await import('ua-parser-js');
-        this.UAParser = UAParser;
         // --- init koa app
         let app = new Koa();
         app.on('error', this.on_error.bind(this));
@@ -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()}  `;
@@ -442,7 +445,7 @@ export class Server {
     }
     format_ua(headers) {
         const { rtt, 'device-memory': memory } = headers;
-        const { device, os, browser } = this.UAParser(headers).withClientHints();
+        const { device, os, browser } = UAParser(headers).withClientHints();
         const vendor = device.vendor?.toLowerCase();
         const model = device.model?.toLowerCase();
         const osname = os.name?.toLowerCase();
@@ -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;
@@ -603,7 +606,6 @@ export class Server {
         let { response } = ctx;
         if (!absolute && !_sea) {
             fp = fp.strip_if_start(fpd_root).strip_if_start('/');
-            const { default: resolve_safely } = await import('resolve-path');
             try {
                 fp = resolve_safely(fpd_root, fp).fp;
             }
@@ -652,10 +654,10 @@ export class Server {
         if (download)
             response.set('content-disposition', `attachment; filename="${encodeURIComponent(fp.fname)}"`);
         if (!response.get('content-type')) {
-            const { contentType: get_content_type } = await import('mime-types');
             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('.'))

package/patches/@types__byte-size@8.1.2.patch

@@ -1,14 +0,0 @@
-# 用来修复 `byte_size()` 函数的 ts 类型报错
-
-diff --git a/package.json b/package.json
-index dd8ed66fcb8b1ab93f0a3a015bad95bc31d3b18d..6a3753f42610451163fd7d502a93779fe3dca8db 100644
---- a/package.json
-+++ b/package.json
-@@ -11,6 +11,7 @@
-             "url": "https://github.com/lntel"
-         }
-     ],
-+    "type": "module",
-     "main": "",
-     "types": "index.d.ts",
-     "repository": {