xshell 1.0.65 → 1.0.66

package/Terminal.d.ts

@@ -1,5 +1,6 @@
 import 'xterm/css/xterm.css';
 import { Terminal as XTermTerminal } from 'xterm';
+import { FitAddon } from 'xterm-addon-fit';
 import { Model } from 'react-object-model';
 import type { Remote } from './net.browser.js';
 export declare function Terminal({ font }: {
@@ -7,7 +8,9 @@ export declare function Terminal({ font }: {
 }): import("react/jsx-runtime").JSX.Element;
 declare class TerminalModel extends Model<TerminalModel> {
     term: XTermTerminal;
+    fit_addon: FitAddon;
     stdio_id: number;
+    fit(): void;
     subscribe_stdio(remote: Remote): Promise<void>;
     unsubscribe_stdio(remote: Remote): Promise<void>;
 }

package/Terminal.js

@@ -29,14 +29,18 @@ export function Terminal({ font }) {
             term.open(rterminal.current);
             term.loadAddon(new WebglAddon());
             fit_addon.fit();
-            terminal.set({ term });
+            terminal.set({ term, fit_addon });
         })();
     }, []);
     return _jsx("div", { className: 'term', ref: rterminal });
 }
 class TerminalModel extends Model {
     term;
+    fit_addon;
     stdio_id = 0;
+    fit() {
+        this.fit_addon?.fit();
+    }
     async subscribe_stdio(remote) {
         assert(!this.stdio_id);
         const id = this.stdio_id = genid();

package/git.d.ts

@@ -0,0 +1,36 @@
+import { type CallOptions } from './process.js';
+export declare class Git {
+    static exe: string;
+    cwd: string;
+    constructor(cwd: string);
+    static init(cwd: string): Promise<Git>;
+    static clone(repo: string, fpd: string): Promise<void>;
+    call(args?: any[], { color, print }?: {
+        color?: boolean;
+        print?: CallOptions['print'];
+    }): Promise<import("./process.js").CallResult<string>>;
+    get_branch(): Promise<string>;
+    /** - print: `true` */
+    get_branches(print?: boolean): Promise<string[]>;
+    has_branch(branch: string): Promise<boolean>;
+    fetch(print?: boolean): Promise<void>;
+    /** - branch?: `'main'` */
+    checkout(branch?: 'main'): Promise<void>;
+    checkout(branch?: string): Promise<void>;
+    _checkout(branch?: string): Promise<void>;
+    merge(branch: string, fast_forward?: boolean): Promise<void>;
+    /** 记住当前分支名
+        checkout 到 <目标分支>
+        merge 当前分支 */
+    merge_into(target_branch?: string): Promise<void>;
+    /** 1. fetch 远程修改
+        2. checkout `<branch>` 分支
+        3. merge `<remote>/<branch>`
+        
+        执行前需要保证工作目录 clean
+        
+        - branch?: `'main'` */
+    update(branch?: 'main'): Promise<void>;
+    update(branch: string): Promise<void>;
+    update(branch: string, remote?: string): Promise<void>;
+}

package/git.js

@@ -0,0 +1,136 @@
+import { assert } from './utils.js';
+import { call } from './process.js';
+import { fread, fmkdir } from './file.js';
+export class Git {
+    static exe = 'git';
+    cwd;
+    constructor(cwd) {
+        this.cwd = cwd;
+    }
+    static async init(cwd) {
+        const git = new Git(cwd);
+        await git.call(['init']);
+        return git;
+    }
+    static async clone(repo, fpd) {
+        await fmkdir(fpd);
+        await new this(fpd).call(['clone', repo, '.']);
+    }
+    async call(args = [], { color = true, print } = {}) {
+        return call(Git.exe, [
+            ...color ? [] : [
+                '-c', 'color.status=false',
+                '-c', 'color.ui=false',
+                '-c', 'color.branch=false',
+            ],
+            ...args,
+        ], {
+            cwd: this.cwd,
+            print,
+        });
+    }
+    async get_branch() {
+        const head = (await fread(`${this.cwd}.git/HEAD`, { print: false })).trim();
+        const branch = head.find('ref: refs/heads/{branch}').branch || head;
+        if (!branch)
+            throw new Error(`${this.cwd} 仓库 Git.get_branch 无法获取到 branch`);
+        return branch;
+        // 需要 100+ ms ，性能太差
+        // this.branch = (await this.git('branch --show-current')).stdout.trim().strip_ansi()
+    }
+    /** - print: `true` */
+    async get_branches(print = true) {
+        return (await this.call(['branch', '-a'], { print })).stdout
+            .split_lines()
+            .map(l => l.strip_ansi())
+            .filter(branch => !branch.includes('origin/HEAD'))
+            .map(branch => branch.rm(/^\* /))
+            .trim_lines();
+    }
+    async has_branch(branch) {
+        return (await this.get_branches(false))
+            .includes(branch);
+    }
+    async fetch(print = true) {
+        if (print)
+            console.log('更新远程分支');
+        await this.call(['fetch', '--all', '--prune'], { print: { code: false, command: false, stdout: true, stderr: true } });
+    }
+    async checkout(branch = 'main') {
+        if (branch === 'main')
+            await this._checkout('main');
+        else {
+            const branches = await this.get_branches(false);
+            if (branches.includes(branch) || branches.find(b => b.endsWith(`/${branch}`) && b.startsWith('remotes/')))
+                await this._checkout(branch);
+            else {
+                console.log(`创建分支 ${branch}`);
+                await this.call(['checkout', '-b', branch], { print: { command: false, code: false, stdout: true, stderr: true } });
+            }
+        }
+    }
+    async _checkout(branch) {
+        try {
+            const { stdout, stderr } = await this.call(['checkout', branch], { print: false });
+            if (stdout)
+                console.log(stdout.trimEnd());
+            console.log(/Already on '.*'\n/.test(stderr) ?
+                `已经在 ${branch} 分支了`
+                : /Switched to branch '.*'/.test(stderr) ?
+                    `已切换到 ${branch} 分支`
+                    :
+                        stderr.trimEnd());
+        }
+        catch (error) {
+            if (error.result) {
+                const { stdout, stderr } = error.result;
+                if (stdout)
+                    console.log(stdout);
+                if (stderr)
+                    console.log(stderr);
+            }
+            throw error;
+        }
+    }
+    async merge(branch, fast_forward = true) {
+        console.log(`合并 ${branch} 分支`);
+        try {
+            const { stdout, stderr } = await this.call([
+                'merge',
+                branch,
+                ...fast_forward ? [] : ['--no-ff']
+            ], { print: false });
+            if (stdout === 'Already up to date.\n')
+                console.log('当前分支无需更新');
+            else
+                console.log(stdout.trimEnd());
+            if (stderr)
+                console.log(stderr);
+        }
+        catch (error) {
+            if (error.result) {
+                const { stdout, stderr } = error.result;
+                if (stdout)
+                    console.log(stdout);
+                if (stderr)
+                    console.log(stderr);
+            }
+            throw error;
+        }
+    }
+    /** 记住当前分支名
+        checkout 到 <目标分支>
+        merge 当前分支 */
+    async merge_into(target_branch = 'main') {
+        const branch = await this.get_branch();
+        assert(branch !== target_branch);
+        await this.checkout(target_branch);
+        await this.merge(branch, true);
+    }
+    async update(branch = 'main', remote = 'origin') {
+        await this.fetch();
+        await this.checkout(branch);
+        await this.merge(`${remote}/${branch}`);
+    }
+}
+//# sourceMappingURL=git.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xshell",
-  "version": "1.0.65",
+  "version": "1.0.66",
   "type": "module",
   "main": "./index.js",
   "bin": {