guito 0.5.3 → 0.6.0

package/bin/ui/browser/worker-O4G7QTZ6.js

@@ -0,0 +1 @@
+function h(a){let n=[],i=new Int32Array(a.length),l=r=>{let t=n.indexOf(r);return t===-1&&(t=n.indexOf(null),t===-1&&(n.push(null),t=n.length-1),n[t]=r),t};for(let r=0;r<a.length;r++){let{hash:t,parents:o}=a[r],s=n.map((e,c)=>e===t?c:-1).filter(e=>e!==-1),p;if(s.length>0){p=s[0];for(let e=1;e<s.length;e++)n[s[e]]=null}else p=l(t);n[p]=o[0]??null;for(let e=1;e<o.length;e++)l(o[e]);i[r]=p}return i}addEventListener("message",a=>{let{id:n,hashes:i,parents:l}=a.data,r=h(i.map((o,s)=>({hash:o,parents:l[s]??[]})));postMessage({id:n,lanes:r},[r.buffer])});

package/bin/working-tree.js

@@ -0,0 +1,141 @@
+import { readFile } from 'node:fs/promises';
+import { isAbsolute, join, relative, resolve, sep } from 'node:path';
+/** NUL-delimited metadata is authoritative: patch headers quote unusual filenames. */
+function names(raw) {
+    const fields = raw.split('\0');
+    const result = [];
+    for (let i = 0; fields[i];) {
+        const code = fields[i++];
+        const first = fields[i++];
+        const renamed = /^[RC]/.test(code);
+        result.push({ code, path: renamed ? fields[i++] : first, oldPath: first });
+    }
+    return result;
+}
+export function workingTree(git, parse) {
+    const hasHead = async () => {
+        try {
+            await git.raw(['rev-parse', '--verify', 'HEAD']);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    async function changes(args) {
+        const common = ['diff', '--no-ext-diff', '--no-textconv', '--no-color', '--find-renames', '--diff-filter=ACDMRT', ...args];
+        const metadata = names(await git.raw([...common, '--name-status', '-z']));
+        const patches = parse(await git.raw([...common, '--patch']));
+        return metadata.map((entry, index) => ({
+            lines: [], additions: 0, deletions: 0, ...patches[index],
+            path: entry.path,
+            oldPath: entry.code[0] === 'A' ? '' : entry.oldPath,
+            status: patches[index]?.status === 'binary' ? 'binary' :
+                ({ A: 'added', D: 'deleted', R: 'renamed' }[entry.code[0]] ?? 'modified'),
+        }));
+    }
+    async function status() {
+        const fields = (await git.raw(['status', '--porcelain=v1', '-z', '--untracked-files=all'])).split('\0');
+        const entries = [];
+        for (let i = 0; fields[i];) {
+            const field = fields[i++];
+            const index = field[0], working = field[1], path = field.slice(3);
+            const oldPath = /[RC]/.test(index + working) ? fields[i++] : '';
+            entries.push({ path, oldPath, index, working });
+        }
+        return entries;
+    }
+    async function untrackedDiff(root, path) {
+        const buffer = await readFile(join(root, path));
+        const binary = buffer.includes(0);
+        const text = buffer.toString('utf8');
+        const lines = text ? text.replace(/\n$/, '').split('\n') : [];
+        return {
+            path, oldPath: '', status: binary ? 'binary' : 'added',
+            lines: binary ? [] : lines.map((text, i) => ({ type: 'add', newLine: i + 1, text })),
+            additions: binary ? 0 : lines.length, deletions: 0,
+        };
+    }
+    async function snapshot() {
+        const root = (await git.revparse(['--show-toplevel'])).trim();
+        const entries = await status();
+        const stagedFiles = await changes(['--cached']);
+        const unstagedFiles = await changes([]);
+        const untracked = entries.filter(e => e.index === '?').map(e => e.path);
+        const conflicted = entries.filter(e => e.index === 'U' || e.working === 'U' || ['AA', 'DD'].includes(e.index + e.working)).map(e => e.path);
+        for (const path of untracked)
+            unstagedFiles.push(await untrackedDiff(root, path));
+        for (const path of conflicted) {
+            if (!unstagedFiles.some(file => file.path === path)) {
+                unstagedFiles.push({ path, oldPath: path, status: 'modified', lines: [], additions: 0, deletions: 0 });
+            }
+        }
+        const combined = await hasHead() ? await changes(['HEAD']) : [...stagedFiles];
+        const files = new Map(combined.map(file => [file.path, file]));
+        // The combined diff can be empty even when index and working changes cancel.
+        for (const file of [...stagedFiles, ...unstagedFiles])
+            if (!files.has(file.path))
+                files.set(file.path, file);
+        return {
+            files: [...files.values()], stagedFiles, unstagedFiles, conflicted,
+            staged: stagedFiles.map(file => file.path),
+            unstaged: unstagedFiles.filter(file => !untracked.includes(file.path)).map(file => file.path),
+            untracked,
+        };
+    }
+    async function validate(files) {
+        if (!Array.isArray(files) || !files.length || files.some(file => typeof file !== 'string' || !file)) {
+            throw new Error('Select at least one file.');
+        }
+        const root = (await git.revparse(['--show-toplevel'])).trim();
+        for (const file of files) {
+            const rel = relative(root, resolve(root, file));
+            if (file.includes('\0') || isAbsolute(file) || !rel || rel === '..' || rel.startsWith(`..${sep}`) ||
+                isAbsolute(rel) || file.split(/[\\/]/).some((part) => part === '..' || part.toLowerCase() === '.git')) {
+                throw new Error('Select repository-relative file paths.');
+            }
+        }
+        return [...new Set(files)];
+    }
+    async function stage(files) {
+        const selected = await validate(files);
+        const entries = await status();
+        const paths = new Set();
+        for (const path of selected) {
+            const entry = entries.find(e => e.path === path);
+            if (!entry)
+                throw new Error(`File is no longer changed: ${path}`);
+            paths.add(path);
+            if (entry.oldPath && /[RC]/.test(entry.working))
+                paths.add(entry.oldPath);
+        }
+        await git.raw(['--literal-pathspecs', 'add', '-A', '--', ...paths]);
+    }
+    async function unstage(files) {
+        const selected = await validate(files);
+        const entries = names(await git.raw(['diff', '--cached', '--name-status', '--find-renames', '-z']));
+        const paths = new Set();
+        for (const path of selected) {
+            const entry = entries.find(e => e.path === path);
+            if (!entry)
+                throw new Error(`File is no longer staged: ${path}`);
+            paths.add(path);
+            paths.add(entry.oldPath);
+        }
+        await git.raw(await hasHead()
+            ? ['--literal-pathspecs', 'reset', '-q', 'HEAD', '--', ...paths]
+            : ['--literal-pathspecs', 'rm', '--cached', '-f', '--ignore-unmatch', '--', ...paths]);
+    }
+    async function commit(message, description) {
+        if (typeof message !== 'string' || !message.trim() || /[\r\n\0]/.test(message))
+            throw new Error('Enter a commit subject on one line.');
+        if (description !== undefined && (typeof description !== 'string' || description.includes('\0')))
+            throw new Error('Invalid commit description.');
+        if ((await git.raw(['ls-files', '--unmerged', '-z'])).length)
+            throw new Error('Resolve conflicts before committing.');
+        if (!(await git.raw(['diff', '--cached', '--name-only', '-z'])).length)
+            throw new Error('Stage changes before committing.');
+        await git.commit([message.trim(), ...(description ? [description] : [])]);
+    }
+    return { snapshot, stage, unstage, commit };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "guito",
-  "version": "0.5.3",
+  "version": "0.6.0",
   "description": "Easily explore your git repositories.",
   "homepage": "https://github.com/danisss9/Guito#readme",
   "repository": {
@@ -50,7 +50,8 @@
     "test": "npm run build:server && node --test tests/*.test.mjs",
     "package:extension": "npm run build:ui && npm run package --workspace vscode-extension",
     "build:start": "npm run build && npm run start",
-    "release": "npm run build && npm publish --access public"
+    "release": "npm run build && npm publish --access public",
+    "test:browser": "npm run build:ui && npm run build:server && playwright test"
   },
   "dependencies": {
     "@fastify/compress": "^9.2.0",
@@ -63,12 +64,14 @@
   },
   "devDependencies": {
     "@angular/build": "^20.0.0",
+    "@angular/cdk": "^20.2.14",
     "@angular/cli": "^20.0.0",
     "@angular/common": "^20.0.0",
     "@angular/compiler": "^20.0.0",
     "@angular/compiler-cli": "^20.0.0",
     "@angular/core": "^20.0.0",
     "@angular/platform-browser": "^20.0.0",
+    "@playwright/test": "^1.63.0",
     "@types/node": "^20.19.43",
     "rxjs": "~7.8.0",
     "tslib": "^2.6.0",

package/playwright.config.mjs

@@ -0,0 +1,9 @@
+import { defineConfig } from '@playwright/test';
+
+export default defineConfig({
+  testDir: './tests/browser',
+  timeout: 30000,
+  workers: 2,
+  use: { baseURL: 'http://127.0.0.1:4173', viewport: { width: 1280, height: 800 }, trace: 'retain-on-failure' },
+  webServer: { command: 'node tests/browser/server.mjs', url: 'http://127.0.0.1:4173', reuseExistingServer: false },
+});