refactor: simplify and optimize initialization logic

.oxlintrc.json

@@ -66,6 +66,12 @@
         "import/named": "off"
       }
     },
+    {
+      "files": ["tests-ext/**/*.ts"],
+      "env": {
+        "mocha": true
+      }
+    },
     {
       "files": ["src/webview/**/*.ts"],
       "env": {

.vscode-test.mjs

@@ -1,7 +1,7 @@
 import { defineConfig } from "@vscode/test-cli";
 
 export default defineConfig({
-  files: "tests/out/extension/**/*.test.js",
+  files: "tests-ext/out/**/*.test.js",
   workspaceFolder: ".",
   version: "stable"
 });

esbuild.js

@@ -33,7 +33,7 @@ const aliasPlugin = {
 
 async function main() {
   const extension = await esbuild.context({
-    entryPoints: ["src/extension.ts"],
+    entryPoints: ["src/extension/main.ts"],
     bundle: true,
     format: "cjs",
     minify: production,

package.json

@@ -36,14 +36,14 @@
   "publisher": "asispts",
   "main": "./out/extension.js",
   "scripts": {
-    "typecheck": "tsc -p ./src --noEmit && tsc -p ./src/webview --noEmit && tsc -p ./tests --noEmit",
+    "typecheck": "tsc -p ./src --noEmit && tsc -p ./src/webview --noEmit && tsc -p ./tests --noEmit && tsc -p ./tests-ext --noEmit",
     "vscode:prepublish": "pnpm run clean && pnpm run package",
     "package": "pnpm run typecheck && pnpm run lint && node esbuild.js --production",
     "clean": "node -e \"require('fs').rmSync('out',{recursive:true,force:true})\"",
     "compile": "pnpm run clean && node esbuild.js",
-    "test": "vitest run --project backend && vitest run --project webview",
+    "test": "vitest run --project backend && vitest run --project extension && vitest run --project webview",
     "test:ext": "pnpm run compile && pnpm run compile-tests && vscode-test",
-    "compile-tests": "tsc -p tests/extension/tsconfig.json && tsc-alias -p tests/extension/tsconfig.json",
+    "compile-tests": "tsc -p tests-ext/tsconfig.json && tsc-alias -p tests-ext/tsconfig.json",
     "watch:esbuild": "node esbuild.js --watch",
     "watch:tsc": "tsc -p ./src --noEmit --watch",
     "format": "oxfmt --check",

src/backend/queries/repoSearch.ts

@@ -0,0 +1,12 @@
+import { searchDirectoryForRepos } from "@/backend/utils/repoSearch";
+
+export async function findGitRepos(
+  paths: string[],
+  gitPath: string,
+  maxDepth: number
+): Promise<string[]> {
+  const results = await Promise.all(
+    paths.map((p) => searchDirectoryForRepos(p, maxDepth, gitPath, []))
+  );
+  return results.flat();
+}

src/extension.ts

@@ -17,6 +17,9 @@ import { initL10n } from "./l10n";
 import { RepoFileWatcher } from "./repoFileWatcher";
 import { StatusBarItem } from "./statusBarItem";
 
+/**
+ * @deprecated See src/extension/main.ts
+ */
 export function activate(context: vscode.ExtensionContext) {
   initL10n(context.extensionPath);
   const outputChannel = vscode.window.createOutputChannel(l10n.t("outputChannel.text"));

src/extension/initExtension.ts

@@ -0,0 +1,155 @@
+import * as path from "path";
+
+import * as vscode from "vscode";
+
+import { AvatarManager } from "@/avatarManager";
+import { GitClient, gitClientFactory } from "@/backend/gitClient";
+import { findGitRepos } from "@/backend/queries/repoSearch";
+import { buildExtensionUri } from "@/backend/utils/path";
+import { config } from "@/config";
+import { DiffDocProvider } from "@/diffDocProvider";
+import { createMaxDepthTracker } from "@/extension/maxDepthTracker";
+import { registerMessageHandlers } from "@/extension/messageHandler";
+import { createRepoManager, RepoManager } from "@/extension/repoManager";
+import { WebviewBridge, webviewBridgeFactory } from "@/extension/webviewBridge";
+import { createWebviewPanel, WebviewPanel } from "@/extension/webviewPanel";
+import { ExtensionState } from "@/extensionState";
+import * as l10n from "@/l10n";
+import { RepoFileWatcher } from "@/repoFileWatcher";
+import { StatusBarItem } from "@/statusBarItem";
+
+export type InitExtension = typeof initExtension;
+
+function registerViewCommand(
+  ctx: vscode.ExtensionContext,
+  repoManager: RepoManager,
+  extensionState: ExtensionState,
+  avatarManager: AvatarManager,
+  gitClient: GitClient
+) {
+  let currentPanel: WebviewPanel | undefined;
+  ctx.subscriptions.push(
+    vscode.commands.registerCommand("neo-git-graph.view", () => {
+      if (currentPanel) {
+        currentPanel.reveal(vscode.window.activeTextEditor?.viewColumn);
+        return;
+      }
+
+      const vsPanel = vscode.window.createWebviewPanel(
+        "neo-git-graph",
+        l10n.t("outputChannel.text"),
+        vscode.window.activeTextEditor?.viewColumn ?? vscode.ViewColumn.One,
+        {
+          enableScripts: true,
+          localResourceRoots: [
+            buildExtensionUri(ctx.extensionPath, "media"),
+            buildExtensionUri(ctx.extensionPath, "out")
+          ]
+        }
+      );
+
+      let bridge!: WebviewBridge;
+      const repoFileWatcher = new RepoFileWatcher(() => {
+        if (vsPanel.visible) bridge.post({ command: "refresh" });
+      });
+      bridge = webviewBridgeFactory(vsPanel.webview, repoFileWatcher);
+      avatarManager.registerBridge(bridge.post.bind(bridge));
+
+      const { onPanelShown } = registerMessageHandlers(bridge, {
+        config,
+        gitClient,
+        repoManager,
+        extensionState,
+        avatarManager,
+        repoFileWatcher
+      });
+
+      currentPanel = createWebviewPanel({
+        panel: vsPanel,
+        bridge,
+        config,
+        repoFileWatcher,
+        extensionPath: ctx.extensionPath,
+        extensionState,
+        avatarManager,
+        repoManager,
+        onDispose: () => {
+          currentPanel = undefined;
+        },
+        onPanelShown
+      });
+    })
+  );
+}
+
+export function initExtension(ctx: vscode.ExtensionContext, repos: string[]) {
+  const extensionState = new ExtensionState(ctx);
+  const avatarManager = new AvatarManager(config.gitPath, extensionState);
+
+  ctx.subscriptions.push(
+    vscode.commands.registerCommand("neo-git-graph.clearAvatarCache", () => {
+      avatarManager.clearCache();
+    })
+  );
+
+  const gitClient = gitClientFactory(extensionState.getLastActiveRepo() ?? "", config.gitPath());
+  ctx.subscriptions.push(
+    vscode.workspace.registerTextDocumentContentProvider(
+      DiffDocProvider.scheme,
+      new DiffDocProvider(gitClient.getInstance)
+    )
+  );
+
+  const maxDepth = createMaxDepthTracker(config.maxDepthOfRepoSearch());
+  const statusBarItem = new StatusBarItem(ctx, config);
+  const repoManager = createRepoManager(extensionState, statusBarItem, config);
+  repoManager.setRepos(repos);
+  registerViewCommand(ctx, repoManager, extensionState, avatarManager, gitClient);
+
+  const gitWatcher = vscode.workspace.createFileSystemWatcher("**/.git");
+  ctx.subscriptions.push(
+    gitWatcher,
+    gitWatcher.onDidCreate((uri) => {
+      const repoPath = path.dirname(uri.fsPath);
+      if (repoManager.addRepo(repoPath)) repoManager.sendRepos();
+    }),
+    gitWatcher.onDidDelete((uri) => {
+      const repoPath = path.dirname(uri.fsPath);
+      if (repoManager.removeReposWithinFolder(repoPath)) repoManager.sendRepos();
+    }),
+    vscode.workspace.onDidChangeWorkspaceFolders(async (e) => {
+      if (e.added.length > 0) {
+        const paths = e.added.map((f) => f.uri.fsPath);
+        const repoDirs = await findGitRepos(paths, config.gitPath(), config.maxDepthOfRepoSearch());
+        for (const repo of repoDirs) repoManager.addRepo(repo);
+        if (repoDirs.length > 0) repoManager.sendRepos();
+      }
+      if (e.removed.length > 0) {
+        let changes = false;
+        for (const folder of e.removed) {
+          if (repoManager.removeReposWithinFolder(folder.uri.fsPath)) changes = true;
+        }
+        if (changes) repoManager.sendRepos();
+      }
+    }),
+    vscode.workspace.onDidChangeConfiguration((e) => {
+      if (e.affectsConfiguration("neo-git-graph.showStatusBarItem")) {
+        statusBarItem.refresh();
+      } else if (e.affectsConfiguration("git.path")) {
+        gitClient.setGitPath(config.gitPath());
+      } else if (e.affectsConfiguration("neo-git-graph.maxDepthOfRepoSearch")) {
+        if (maxDepth.increased(config.maxDepthOfRepoSearch())) {
+          const paths = (vscode.workspace.workspaceFolders ?? []).map((f) => f.uri.fsPath);
+          void findGitRepos(paths, config.gitPath(), config.maxDepthOfRepoSearch()).then(
+            (repoDirs) => {
+              if (repoDirs.length > 0) {
+                repoManager.setRepos(repoDirs);
+                repoManager.sendRepos();
+              }
+            }
+          );
+        }
+      }
+    })
+  );
+}

src/extension/main.ts

@@ -0,0 +1,23 @@
+import * as vscode from "vscode";
+
+import { findGitRepos } from "@/backend/queries/repoSearch";
+import { config } from "@/config";
+import { initExtension } from "@/extension/initExtension";
+import { watchForRepos } from "@/extension/watchForRepos";
+import * as l10n from "@/l10n";
+
+export async function activate(ctx: vscode.ExtensionContext) {
+  l10n.initL10n(ctx.extensionUri.fsPath);
+
+  const paths = (vscode.workspace.workspaceFolders ?? []).map((f) => f.uri.fsPath);
+  const repoDirs = await findGitRepos(paths, config.gitPath(), config.maxDepthOfRepoSearch());
+
+  if (repoDirs.length > 0) {
+    initExtension(ctx, repoDirs);
+    return;
+  }
+
+  ctx.subscriptions.push(watchForRepos(ctx, initExtension));
+}
+
+export function deactivate() {}

src/extension/maxDepthTracker.ts

@@ -0,0 +1,10 @@
+export function createMaxDepthTracker(initialDepth: number) {
+  let current = initialDepth;
+  return {
+    increased: (newDepth: number) => {
+      const prev = current;
+      current = newDepth;
+      return current > prev;
+    }
+  };
+}

src/extension/repoManager.ts

@@ -25,6 +25,16 @@ export function createRepoManager(
   let repos = extensionState.getRepos();
   let viewCallback: ((repos: GitRepoSet, numRepos: number) => void) | null = null;
 
+  function setRepos(repoDirs: string[]) {
+    for (const key of Object.keys(repos)) {
+      delete repos[key];
+    }
+    for (const repo of repoDirs) {
+      repos[repo] = { columnWidths: null };
+    }
+    extensionState.saveRepos(repos);
+  }
+
   function getRepos() {
     return sortRepos(repos);
   }
@@ -58,8 +68,10 @@ export function createRepoManager(
   }
 
   function addRepo(repo: string) {
+    if (repos[repo]) return false;
     repos[repo] = { columnWidths: null };
     extensionState.saveRepos(repos);
+    return true;
   }
 
   function removeReposWithinFolder(path: string) {
@@ -123,9 +135,10 @@ export function createRepoManager(
   return {
     registerViewCallback,
     deregisterViewCallback,
-    getRepos,
     isDirectoryWithinRepos,
+    getRepos,
     sendRepos,
+    setRepos,
     addRepo,
     removeRepo,
     removeReposWithinFolder,

src/extension/watchForRepos.ts

@@ -0,0 +1,66 @@
+import * as vscode from "vscode";
+
+import { findGitRepos } from "@/backend/queries/repoSearch";
+import { config } from "@/config";
+import type { InitExtension } from "@/extension/initExtension";
+import { createMaxDepthTracker } from "@/extension/maxDepthTracker";
+import * as l10n from "@/l10n";
+
+type WatcherState = {
+  disposed: boolean;
+  disposables: vscode.Disposable[];
+};
+
+function dispose(state: WatcherState) {
+  state.disposed = true;
+  for (const d of state.disposables) d.dispose();
+  state.disposables.length = 0;
+}
+
+async function check(
+  ctx: vscode.ExtensionContext,
+  state: WatcherState,
+  onReposFound: InitExtension
+) {
+  if (state.disposed) return;
+  const paths = (vscode.workspace.workspaceFolders ?? []).map((f) => f.uri.fsPath);
+  const repoDirs = await findGitRepos(paths, config.gitPath(), config.maxDepthOfRepoSearch());
+  if (repoDirs.length === 0 || state.disposed) return;
+  dispose(state);
+  onReposFound(ctx, repoDirs);
+}
+
+export function watchForRepos(
+  ctx: vscode.ExtensionContext,
+  onReposFound: InitExtension
+): { dispose(): void } {
+  const maxDepth = createMaxDepthTracker(config.maxDepthOfRepoSearch());
+  const gitWatcher = vscode.workspace.createFileSystemWatcher("**/.git");
+  const state: WatcherState = { disposed: false, disposables: [gitWatcher] };
+
+  state.disposables.push(
+    gitWatcher.onDidCreate(() => check(ctx, state, onReposFound)),
+    vscode.workspace.onDidChangeWorkspaceFolders(() => check(ctx, state, onReposFound)),
+    vscode.workspace.onDidChangeConfiguration((e) => {
+      if (e.affectsConfiguration("neo-git-graph.maxDepthOfRepoSearch")) {
+        if (maxDepth.increased(config.maxDepthOfRepoSearch())) {
+          void check(ctx, state, onReposFound);
+        }
+      }
+    }),
+    vscode.commands.registerCommand("neo-git-graph.view", async () => {
+      await vscode.window.showErrorMessage(l10n.t("statusBar.text"), {
+        detail: l10n.t("error.noGitRepository"),
+        modal: true
+      });
+    }),
+    vscode.commands.registerCommand("neo-git-graph.clearAvatarCache", async () => {
+      await vscode.window.showErrorMessage(l10n.t("statusBar.text"), {
+        detail: l10n.t("error.noGitRepository"),
+        modal: true
+      });
+    })
+  );
+
+  return { dispose: () => dispose(state) };
+}

tests/extension/tsconfig.json → tests-ext/tsconfig.json

@@ -1,10 +1,10 @@
 {
   "extends": "../tsconfig.json",
   "compilerOptions": {
-    "noEmit": false,
-    "module": "commonjs",
+    "module": "CommonJS",
     "moduleResolution": "node",
-    "outDir": "../out/extension"
+    "noEmit": false,
+    "outDir": "./out"
   },
   "include": ["./**/*.ts"]
 }