@youtyan/code-viewer 0.1.4 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@youtyan/code-viewer",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Local browser-based git diff viewer",
   "type": "module",
   "bin": {

package/web/app.js

@@ -382,12 +382,13 @@
       button.innerHTML = expanded ? iconSvg("octicon-fold", FOLD_16_PATH) : iconSvg("octicon-unfold", UNFOLD_16_PATH);
     }
     function buildTree(files) {
-      const root = { name: "", dirs: {}, files: [], path: "", minOrder: Infinity };
+      const root = { name: "", dirs: {}, files: [], path: "", minOrder: Infinity, explicit: true };
       for (const f of files) {
         const parts = f.path.split("/");
         let node = root;
         let acc = "";
-        for (let i = 0;i < parts.length - 1; i++) {
+        const dirPartCount = f.type === "tree" ? parts.length : parts.length - 1;
+        for (let i = 0;i < dirPartCount; i++) {
           const p = parts[i];
           acc = acc ? acc + "/" + p : p;
           if (!node.dirs[p]) {
@@ -397,11 +398,15 @@
           if (typeof f.order === "number" && f.order < node.minOrder)
             node.minOrder = f.order;
         }
+        if (f.type === "tree") {
+          node.explicit = true;
+          continue;
+        }
         node.files.push(f);
       }
       function compress(node) {
         const ks = Object.keys(node.dirs);
-        while (ks.length === 1 && node.files.length === 0 && node !== root) {
+        while (ks.length === 1 && node.files.length === 0 && !node.explicit && node !== root) {
           const only = node.dirs[ks[0]];
           node.name = node.name ? node.name + "/" + only.name : only.name;
           node.dirs = only.dirs;
@@ -432,6 +437,8 @@
           const li = document.createElement("li");
           li.className = "tree-dir";
           li.dataset.dirpath = dir.path;
+          if (dir.explicit)
+            li.dataset.explicit = "true";
           li.style.setProperty("--lvl-pad", 12 + depth * 14 + "px");
           const chev = document.createElement("span");
           chev.className = "chev";
@@ -650,17 +657,19 @@
         const match = matches(card.dataset.path || "");
         card.classList.toggle("hidden-by-filter", !match);
       });
-      updateTreeDirVisibility();
+      updateTreeDirVisibility(matches, filter.kind !== "empty" && !invalid);
       if (typeof applyViewedState === "function")
         applyViewedState();
     }
-    function updateTreeDirVisibility() {
+    function updateTreeDirVisibility(dirMatches, filterActive = false) {
       $$("#filelist .tree-dir").forEach((dir) => {
         const childUl = dir.nextElementSibling;
         if (!childUl || !childUl.classList.contains("tree-children"))
           return;
         const anyVisible = !!childUl.querySelector(".tree-file:not(.hidden):not(.hidden-by-tests)");
-        dir.classList.toggle("hidden", !anyVisible);
+        const explicitVisible = dir.dataset.explicit === "true" && !filterActive;
+        const selfMatches = filterActive && !!dirMatches && dirMatches(dir.dataset.dirpath || "");
+        dir.classList.toggle("hidden", !anyVisible && !explicitVisible && !selfMatches);
       });
     }
     let SERVER_GENERATION = 0;
@@ -1030,10 +1039,11 @@
           throw new Error("failed to load repository tree");
         return r.json();
       })).then((meta) => {
-        const files = meta.entries.filter((entry) => entry.type !== "tree").map((entry, index) => ({
+        const files = meta.entries.map((entry, index) => ({
           order: index + 1,
           path: entry.path,
-          display_path: entry.path
+          display_path: entry.path,
+          type: entry.type
         }));
         renderSidebar(files, (file) => {
           setRoute({ screen: "file", path: file.path, ref, view: "blob", range: currentRange() });

package/web/style.css

@@ -714,10 +714,11 @@ html, body {
 
 /* ===== Sidebar resizer (drag right edge to resize) ===== */
 #sidebar-resizer {
-  position: absolute;
-  top: 0; right: -3px;
-  width: 6px;
-  height: 100%;
+  position: fixed;
+  top: var(--chrome-h);
+  bottom: 0;
+  left: calc(var(--sidebar-w) - 4px);
+  width: 8px;
   cursor: col-resize;
   z-index: 31;
   background: transparent;
@@ -741,7 +742,6 @@ body.gdp-resizing #sidebar-resizer {
   pointer-events: none;
   box-shadow: 0 0 0 4px color-mix(in srgb, var(--accent) 25%, transparent);
 }
-#sidebar { position: fixed; }  /* ensure relative ancestor for resizer */
 body.gdp-resizing { cursor: col-resize !important; user-select: none; }
 body.gdp-resizing * { user-select: none !important; }
 

package/web-src/server/git.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 
 export type GitFileMeta = {
@@ -130,27 +130,72 @@ function normalizeTreePath(path: string): string {
   return path.replace(/^\/+|\/+$/g, '');
 }
 
-function directChildren(paths: string[], basePath: string): GitTreeEntry[] {
-  const base = normalizeTreePath(basePath);
-  const prefix = base ? `${base}/` : '';
-  const entries = new Map<string, GitTreeEntry>();
-  for (const rawPath of paths) {
-    if (!rawPath || (prefix && !rawPath.startsWith(prefix))) continue;
-    const rest = prefix ? rawPath.slice(prefix.length) : rawPath;
-    if (!rest) continue;
-    const slash = rest.indexOf('/');
-    const name = slash >= 0 ? rest.slice(0, slash) : rest;
-    const childPath = prefix + name;
-    const type = slash >= 0 ? 'tree' : 'blob';
-    const existing = entries.get(childPath);
-    if (!existing || existing.type !== 'tree') entries.set(childPath, { name, path: childPath, type });
-  }
-  return [...entries.values()].sort((a, b) => {
+function sortTreeEntries(entries: GitTreeEntry[]): GitTreeEntry[] {
+  return [...entries].sort((a, b) => {
     if (a.type !== b.type) return a.type === 'tree' ? -1 : 1;
     return a.name.localeCompare(b.name);
   });
 }
 
+function worktreeDirectChildren(cwd: string, path: string): GitTreeEntry[] {
+  const base = normalizeTreePath(path);
+  const dir = join(cwd, base);
+  try {
+    return sortTreeEntries(readdirSync(dir, { withFileTypes: true }).map((entry) => {
+      const entryPath = base ? `${base}/${entry.name}` : entry.name;
+      return {
+        name: entry.name,
+        path: entryPath,
+        type: entry.isDirectory() ? 'tree' as const : 'blob' as const,
+      };
+    }));
+  } catch {
+    return [];
+  }
+}
+
+function worktreeRecursiveFiles(cwd: string, path: string): GitTreeEntry[] {
+  const base = normalizeTreePath(path);
+  const trackedArgs = ['git', '-c', 'core.quotepath=false', 'ls-files', '-z'];
+  if (base) trackedArgs.push('--', `${base}/`);
+  const tracked = run(trackedArgs, cwd);
+  const paths = tracked.code === 0 ? tracked.stdout.split('\0').filter(Boolean) : [];
+  paths.push(...untracked(cwd, base));
+  return [...new Set(paths)].filter(Boolean).sort().map((entryPath) => ({
+    name: entryPath.split('/').pop() || entryPath,
+    path: entryPath,
+    type: 'blob' as const,
+  }));
+}
+
+function gitTreeEntries(ref: string, path: string, cwd: string, recursive: boolean): { code: number; entries: GitTreeEntry[]; stderr: string } {
+  const base = normalizeTreePath(path);
+  const args = ['git', '-c', 'core.quotepath=false', 'ls-tree'];
+  if (recursive) args.push('-r');
+  args.push('-z', '--full-tree', ref, '--');
+  if (base) args.push(`${base}/`);
+  const res = run(args, cwd);
+  if (res.code !== 0) return { code: res.code, entries: [], stderr: res.stderr };
+  const allowedTypes = recursive ? 'blob|commit' : 'tree|blob|commit';
+  let entries = res.stdout.split('\0').filter(Boolean).map((rec) => {
+    const match = rec.match(new RegExp(`^\\d+\\s+(${allowedTypes})\\s+[0-9a-fA-F]+\\t(.+)$`));
+    if (!match) return null;
+    const entryPath = match[2];
+    return { name: entryPath.split('/').pop() || entryPath, path: entryPath, type: match[1] as GitTreeEntry['type'] };
+  }).filter((entry): entry is GitTreeEntry => !!entry);
+  if (recursive) entries.sort((a, b) => a.path.localeCompare(b.path));
+  else entries = sortTreeEntries(entries);
+  return { code: 0, entries, stderr: '' };
+}
+
+function combineDirectAndRecursiveFiles(directEntries: GitTreeEntry[], fileEntries: GitTreeEntry[]): GitTreeEntry[] {
+  const seen = new Set(directEntries.map((entry) => entry.path));
+  return [
+    ...directEntries,
+    ...fileEntries.filter((entry) => !seen.has(entry.path)),
+  ];
+}
+
 export function worktreeEntries(cwd: string, path: string): GitTreeEntry[] {
   return listTree('worktree', path, cwd).entries;
 }
@@ -175,41 +220,16 @@ export function listTree(
 ): { code: number; entries: GitTreeEntry[]; stderr: string } {
   const base = normalizeTreePath(path);
   if (ref === 'worktree') {
-    const trackedArgs = ['git', '-c', 'core.quotepath=false', 'ls-files', '-z'];
-    if (!options.recursive) trackedArgs.push('--', base ? `${base}/` : '.');
-    const tracked = run(trackedArgs, cwd);
-    const paths = tracked.code === 0 ? tracked.stdout.split('\0').filter(Boolean) : [];
-    paths.push(...untracked(cwd, options.recursive ? '' : base));
-    const uniquePaths = [...new Set(paths)].filter(Boolean);
-    const entries = options.recursive
-      ? uniquePaths.sort().map((entryPath) => ({
-        name: entryPath.split('/').pop() || entryPath,
-        path: entryPath,
-        type: 'blob' as const,
-      }))
-      : directChildren(uniquePaths, base);
-    return { code: 0, entries, stderr: '' };
+    const directEntries = worktreeDirectChildren(cwd, base);
+    if (!options.recursive) return { code: 0, entries: directEntries, stderr: '' };
+    return { code: 0, entries: combineDirectAndRecursiveFiles(directEntries, worktreeRecursiveFiles(cwd, base)), stderr: '' };
   }
 
-  const args = ['git', '-c', 'core.quotepath=false', 'ls-tree'];
-  if (options.recursive) args.push('-r');
-  args.push('-z', '--full-tree', ref, '--');
-  if (!options.recursive && base) args.push(`${base}/`);
-  const res = run(args, cwd);
-  if (res.code !== 0) return { code: res.code, entries: [], stderr: res.stderr };
-  const allowedTypes = options.recursive ? 'blob|commit' : 'tree|blob|commit';
-  const entries = res.stdout.split('\0').filter(Boolean).map((rec) => {
-    const match = rec.match(new RegExp(`^\\d+\\s+(${allowedTypes})\\s+[0-9a-fA-F]+\\t(.+)$`));
-    if (!match) return null;
-    const entryPath = match[2];
-    return { name: entryPath.split('/').pop() || entryPath, path: entryPath, type: match[1] as GitTreeEntry['type'] };
-  }).filter((entry): entry is GitTreeEntry => !!entry);
-  entries.sort((a, b) => {
-    if (options.recursive) return a.path.localeCompare(b.path);
-    if (a.type !== b.type) return a.type === 'tree' ? -1 : 1;
-    return a.name.localeCompare(b.name);
-  });
-  return { code: 0, entries, stderr: '' };
+  const direct = gitTreeEntries(ref, base, cwd, false);
+  if (direct.code !== 0 || !options.recursive) return direct;
+  const recursive = gitTreeEntries(ref, base, cwd, true);
+  if (recursive.code !== 0) return recursive;
+  return { code: 0, entries: combineDirectAndRecursiveFiles(direct.entries, recursive.entries), stderr: '' };
 }
 
 export function untrackedMeta(cwd: string): GitFileMeta[] {

package/web-src/server/preview.ts

@@ -262,8 +262,13 @@ function safeRepoPath(path: string) {
   return path === '' || safePath(path);
 }
 
+function isGitInternalPath(path: string): boolean {
+  return path === '.git' || path.startsWith('.git/');
+}
+
 function safeWorktreePath(path: string): string | null {
   if (!safePath(path)) return null;
+  if (isGitInternalPath(path)) return null;
   const full = join(cwd, path);
   if (!existsSync(full)) return null;
   const realCwd = realpathSync(cwd);
@@ -296,6 +301,7 @@ function handleTree(url: URL) {
   const target = url.searchParams.get('ref') || url.searchParams.get('target') || 'worktree';
   const path = (url.searchParams.get('path') || '').replace(/^\/+|\/+$/g, '');
   if (!safeRepoPath(path)) return text('invalid path', 400);
+  if ((target === 'worktree' || target === '') && isGitInternalPath(path)) return text('forbidden', 403);
   if (target !== 'worktree' && !git.verifyTreeRef(target, cwd)) return text('invalid target', 400);
   const recursive = url.searchParams.get('recursive') === '1';
   const entries = git.listTree(target, path, cwd, { recursive }).entries;