xshell 1.2.89 → 1.3.0

package/antd.sass

@@ -1,3 +1,5 @@
+// 全局的 antd 覆盖样式，使用 antd 的都需要
+
 .ant-modal-root
     // 增加 modal 标题下方空白
     .ant-modal-header
@@ -10,34 +12,5 @@
         .ant-modal-content
             padding: 20px
 
-
-@mixin height()
-    .ant-table-wrapper
-        height: 100%
-        
-        .ant-spin-nested-loading
-            height: 100%
-            
-            .ant-spin-container
-                height: 100%
-                display: flex
-                flex-direction: column
-            
-            .ant-table-container
-                height: 100%
-                display: flex
-                flex-direction: column
-                
-                .ant-table-body
-                    position: relative
-                    flex: 1
-                    
-                    table
-                        position: absolute
-                        left: 0
-                        top: 0
-                        right: 0
-                        bottom: 0
-            
-            .ant-table
-                flex: 1
+.ant-splitter .ant-splitter-panel
+    scrollbar-width: unset

package/builder.js

@@ -4,18 +4,6 @@ import { noprint } from "./process.js";
 import { Lock, filter_values } from "./utils.js";
 import { fcopy, fmkdir, fwrite, fread, print_info } from "./file.js";
 import { path } from "./path.js";
-const monaco_files = [
-    'loader.js',
-    'nls.messages.zh-cn.js',
-    'editor/editor.main.js',
-    'editor/editor.main.css',
-    'base/worker/workerMain.js',
-    'base/browser/ui/codicons/codicon/codicon.ttf',
-    ...['python', 'javascript', 'typescript', 'css', 'html', 'cpp', 'sql', 'scss', 'shell'].map(language => `basic-languages/${language}/${language}.js`),
-    // 太大了，先不加
-    // 'language/typescript/tsMode.js',
-    // 'language/typescript/tsWorker.js',
-];
 function get_react_js(production, src, map) {
     return `${src ? import.meta.dirname.fpd : 'vendors/react/'}react.${production ? 'production' : 'development'}.js${map ? '.map' : ''}`;
 }
@@ -89,8 +77,8 @@ const dependencies = {
     },
     monaco: {
         assets: {
-            productions: monaco_files.map(fp => `monaco-editor/min/vs/${fp}`),
-            devs: monaco_files.map(fp => `monaco-editor/dev/vs/${fp}`)
+            productions: ['monaco-editor/min/vs/'],
+            devs: ['monaco-editor/dev/vs/']
         },
         maps: {
             productions: [
@@ -227,6 +215,9 @@ export class Bundler {
                         loader: get_loader('sass-loader'),
                         options: {
                             api: 'modern-compiler',
+                            sassOptions: {
+                                style: 'expanded'
+                            },
                             ...sass ? {
                                 implementation: sass
                             } : {},

package/file.d.ts

@@ -51,7 +51,7 @@ export interface FReadOptions {
     print?: boolean;
 }
 export declare function fread(fp: string | FileHandle): Promise<string>;
-export declare function fread(fp: string | FileHandle, options?: FReadOptions & {
+export declare function fread(fp: string | FileHandle, options: FReadOptions & {
     encoding: 'binary';
 }): Promise<Buffer>;
 export declare function fread(fp: string | FileHandle, options?: FReadOptions & {
@@ -287,7 +287,7 @@ export declare function ftail(fp: string, handler: (lines: string[]) => void | P
     print?: boolean;
 }): Promise<fs.FSWatcher>;
 /** 打开一个文件并搜索替换某个 pattern */
-export declare function freplace(fp: string, pattern: string | RegExp, replacement: string, { print }?: {
+export declare function freplace(fp: string, pattern: string | RegExp, replacement: string | ((substring: string, ...args: any[]) => string), { print }?: {
     print?: boolean;
 }): Promise<void>;
 interface FSyncOptions {

package/file.js

@@ -12,7 +12,7 @@ export const print_files = { info: true, files: true };
 export const print_info = { info: true, files: false };
 export const print_info_options = { print: print_info };
 export const binary_encoding = { encoding: 'binary' };
-export const ramdisk = fexists('T:/TEMP/', noprint);
+export const ramdisk = fexists('T:/TEMP/', { print: false });
 /** fp 所指向的 文件/ 文件夹 是否存在
     - print?: `true` */
 export function fexists(fp, { print = true } = {}) {

package/i18n/dict.json

@@ -385,5 +385,17 @@
     },
     "fsend 必须传 absolute 选项, sea 选项, 或 fpd_root 文件夹": {
         "en": "fsend must be passed the absolute option, the sea option, or the fpd_root folder"
+    },
+    "对端关闭": {
+        "en": "endpoint is going away"
+    },
+    "网络中断": {
+        "en": "network interruption"
+    },
+    "chtext": {
+        "en": "chtext"
+    },
+    "key": {
+        "en": "key"
     }
 }

package/i18n/scanner/index.d.ts

@@ -48,4 +48,5 @@ export type Config = Partial<(typeof default_config) & {
         lineEnding?: '\n';
     };
 }>;
+export declare function try_load_dict(fp_dict: string): Promise<any>;
 export {};

package/i18n/scanner/index.js

@@ -1,12 +1,11 @@
 import { Parser } from 'i18next-scanner';
 import "../../prototype.js";
 import { path } from "../../path.js";
-import { flist, fread, fwrite } from "../../file.js";
+import { flist, fread, fwrite, fread_json } from "../../file.js";
 import { noprint } from "../../process.js";
 import { rethrow } from "../../prototype.js";
 import { languages } from "../index.js";
 import { RWDict } from "../rwdict.js";
-import { try_load_dict } from "../utils.js";
 import { parse_trans_from_string_by_babel } from "./parser.js";
 /** 扫描源码中的词条，以及收集未翻译的词条，将结果保存到 dict.json 和 untranslateds.json
     - `process.cwd()` rootdir 要扫描根目录
@@ -65,7 +64,7 @@ export async function scanner(fpd_root, config = {}) {
         print: false,
         deep: true,
         filter: fp => fp.isdir ?
-            !(fp.startsWith('.') || excludes.includes(fp.fname))
+            !(fp.startsWith('.') || excludes.has(fp.fname))
             :
                 fp.endsWith('.ts') && !fp.endsWith('.d.ts') || fp.endsWith('.tsx')
     }))
@@ -141,11 +140,12 @@ function pad(str, index) {
     return str.pad(widths[index], { position: 'left' });
 }
 const widths = [6, 8, 8];
-const excludes = [
+const excludes = new Set([
     'node_modules/',
     'out/',
     'dist/',
-];
+    'test/'
+]);
 /** 默认 i18next 扫描配置 */
 const default_config = {
     debug: false,
@@ -221,4 +221,13 @@ const default_config = {
         suffix: '}}' // suffix for interpolation
     }
 };
+export async function try_load_dict(fp_dict) {
+    try {
+        return await fread_json(fp_dict, { print: false });
+    }
+    catch {
+        // console.error('未找到或解析错误，跳过加载：' + modpath)
+        return {};
+    }
+}
 //# sourceMappingURL=index.js.map

package/net.browser.d.ts

@@ -1,6 +1,4 @@
-import { type Message } from './io.common.ts';
-import { Lock } from './utils.browser.ts';
-import { type BasicAuth, type BearerAuth, type RemoteKeeperOptions } from './net.common.ts';
+import { type BasicAuth, type BearerAuth } from './net.common.ts';
 export * from './net.common.ts';
 export interface FullResponse<TBody extends ArrayBuffer | string> {
     status: number;
@@ -58,142 +56,3 @@ export declare function request(url: string | URL, options: RequestOptions & {
 export declare function request(url: string | URL, options: RequestOptions): Promise<string>;
 /** 发起 http 请求并将响应体作为 json 解析 */
 export declare function request_json<T = any>(url: string, options?: RequestOptions): Promise<T>;
-export declare class WebSocketConnectionError extends Error {
-    name: "WebSocketConnectionError";
-    url: string;
-    protocols?: string[];
-    event: CloseEvent | /* error 事件时的 event，没有 event.error */ Event;
-    type: 'close' | 'error';
-    code?: number;
-    reason?: string;
-    constructor(url: string, protocols: string[] | undefined, event: CloseEvent | Event, message?: string);
-}
-/** 连接 websocket url, 设置各种事件监听器。在 open 事件后 resolve, 返回 websocket
-    遇到 error 时会创建 WebSocketConnectionError:
-        - reject 掉返回的 promise (若此时未 settle)
-        - 作为参数调用 on_error (已 settle 且有 on_error 回调)
-    可以用 WebSocket.bufferedAmount 来显示大消息的发送进度
-    https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/bufferedAmount
-    - url
-    - options:
-        - protocols?
-        - on_message: 根据 websocket frame 的 opcode 不同 (text frame 或 binary frame)，event 中的 data 对应为 ArrayBuffer 或者 string
-          https://datatracker.ietf.org/doc/html/rfc6455#section-5.2
-        - on_error?: 在 websocket 出错和非正常关闭 (close, error 事件) 时都调用，可以根据 error.type 来区分，error 的类型是 WebSocketConnectionError，
-            type 为 'close' 时有 code 和 reason 属性
-        - on_close?: 和 websocket 的 'close' 事件不相同，只在正常关闭 (close code 为 1000) 时才调用，否则都会调用 on_error
-            https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes
-        - print?: 是否打印连接、关闭信息 */
-export declare function connect_websocket(url: string | URL, { protocols, on_message, on_error, on_close, print }: {
-    protocols?: string[];
-    on_message(data: ArrayBuffer | string, websocket: WebSocket): any;
-    on_error?(error: WebSocketConnectionError, websocket: WebSocket): any;
-    on_close?(event: CloseEvent, websocket: WebSocket): any;
-    print?: boolean;
-}): Promise<WebSocket>;
-/** 接收到消息后的处理函数
-    返回值会自动被 await，然后可能被封装为 message 回传 */
-export type MessageHandler<TData = any> = (message: Message<TData>, websocket?: WebSocket) => void | any | Promise<void | any>;
-/** 通过创建 remote 对象对 websocket rpc 进行抽象
-    创建 remote 对象时传入 funcs 注册处理函数，使得对端能通过 (rpc message).func 调用
-    使用 remote.handle 方法处理对端发来的 websocket message，对于 websocket 连接接收方需要手动绑定 websocket message 事件到 remote.handle
-    使用 remote.call 进行一元 rpc
-    使用 remote.send 结合 message.id 进行复杂 rpc
-    创建后等到首个 remote.call 或 remote.send 时自动建立实际 websocket 连接
-    rpc 状态与底层连接的状态无关，如果是传入 url 创建的 remote 实例，remote.send 时检测到断线会自动建立新的 websocket 连接
-    
-    @example
-    // Zero 继承自 Remote 并通过 call 实现了一些方法
-    let zero = new Zero({ local: true })
-    
-    // 一元 rpc
-    await zero.repl_ts('1234')
-    
-    // 订阅流
-    const id = genid()
-    
-    zero.handlers.set(id, ({ data: [chunk] }: Message<[Uint8Array]>) => {
-        term.write(chunk)
-    })
-    
-    zero.send({ id, func: 'subscribe_stdio' }) */
-export declare class Remote {
-    /** 在构造 Remote 时, this.initiator = Boolean(url || websocket)
-        - true:  作为 websocket 连接发起方
-        - false: 作为 websocket 连接接收方 */
-    initiator: boolean;
-    /** 作为 websocket 连接发起方，对端的 url 地址 */
-    url?: string;
-    /** 作为 websocket 连接发起方有 websocket lock */
-    lwebsocket?: Lock<WebSocket>;
-    /** websocket 连接发起方，接收方，都能被对端通过 (rpc message).func 调用的 rpc 函数 */
-    funcs: Record<string, MessageHandler>;
-    /** map<id, message handler>: 通过 (rpc message).id 找到对应的 handler
-        一元 rpc 接收方不需要设置 handlers, 发送方需要 */
-    handlers: Map<number, MessageHandler<any>>;
-    keeper?: RemoteKeeperOptions;
-    /** `true` 是否打印连接信息、错误信息 */
-    print: boolean;
-    /** `false` 打印所有交互的 rpc messages */
-    verbose: boolean;
-    first_error: boolean;
-    keeping: boolean;
-    reconnecting: boolean;
-    disconnected: boolean;
-    /** 作为 websocket 连接发起方，传入 url 或 websocket，定义远程 Remote
-        作为 websocket 连接接收方，不传 url 和 websocket，定义本地 Remote */
-    constructor({ url, funcs, print, verbose, websocket, keeper, on_error, }?: {
-        url?: string;
-        funcs?: Remote['funcs'];
-        print?: boolean;
-        verbose?: boolean;
-        websocket?: WebSocket;
-        keeper?: RemoteKeeperOptions;
-        on_error?(error: WebSocketConnectionError | Error, websocket?: WebSocket): void;
-    });
-    /** 统一处理首次连接和连接后的 websocket 错误 */
-    _on_error: (error: WebSocketConnectionError, websocket?: WebSocket) => void;
-    _on_message: (data: ArrayBuffer, websocket: WebSocket) => void;
-    /** 使用者自定义的在 websocket 连接出错时，或者 handlers 出错时的处理 */
-    on_error(error: WebSocketConnectionError | Error, websocket?: WebSocket): void;
-    /** 幂等，保证 websocket 已连接，否则抛出异常
-        一般情况不需要手动调用，在其它方法中会自动调用这个方法，除非需要手动建立 websocket 连接并确保成功
-        连接断开后，通过传入 url 参数构造的 remote 实例会自动创建新的 websocket 连接，而通过传入 websocket 参数构造的实例只会检查连接状态，在断开时抛出异常
-        作为 websocket 连接发起方，不需要传入 websocket
-        作为 websocket 连接接收方，需要传入使用的 websocket 连接，确保这个这个连接的状态 */
-    connect(websocket?: WebSocket): Promise<void>;
-    /** 作为 websocket 连接发起方手动关闭到对端的 websocket 连接 */
-    disconnect(): void;
-    /** 发送 message 到对端 remote
-        作为 websocket 连接发起方，不需要传入 websocket
-        作为 websocket 连接接收方，必传 websocket 参数
-        发送或连接出错时自动清理 message.id 对应的 handler */
-    send(message: Message, websocket?: WebSocket): Promise<void>;
-    /** 处理接收到的 websocket message 并解析, 根据 message.id 或 message.func 分发到对应的 handler 进行处理，
-        handler 处理完成后:
-        - 传了 func: 调用函数的情况下 (通常是一元 rpc)，总是将返回值包装为 message 回传
-        - 未传 func: 通过 id 调用，如果 handler 返回非 undefined 的值，也包装为 message 回传
-        
-        如果 message.done == true 则对端指示当前 remote 可以清理 handler
-        使用 Uint8Array 作为参数更灵活 https://stackoverflow.com/a/74505197/7609214
-        这个方法一般不会抛出错误，也不需要 await，一般在 websocket on_message 时使用 */
-    handle(data: Uint8Array, websocket: WebSocket): Promise<void>;
-    /** 调用对端 remote 中的 func, 只适用于最简单的一元 rpc (请求, 响应)
-        作为 websocket 连接发起方，不需要传入 websocket
-        作为 websocket 连接接收方，必传 websocket 参数  */
-    call<TReturn = any>(func: string, args?: any[], websocket?: WebSocket): Promise<TReturn>;
-    /** 调用对端 remote 中的 func, 开始订阅并接收连续的消息 (订阅流)
-        - func: 订阅处理函数
-        - on_data: 接收开始订阅后的数据
-        - options?:
-            - on_error?: 处理开始订阅后的错误
-            - websocket?: 作为 websocket 连接接收方，必传 websocket 参数 */
-    subscribe<TData, TSubscribed = void>(func: string, on_data: (data: TData) => void, { on_error, websocket }?: RemoteSubscribeOptions): Promise<{
-        id: number;
-        data: TSubscribed;
-    }>;
-}
-export interface RemoteSubscribeOptions {
-    on_error?(error: Error): void;
-    websocket?: WebSocket;
-}