fix: respect tsconfig exclude patterns in file watcher

- Add getProjectConfig() to language server to expose parsed tsconfig
- Process wildcard directories in svelte-check to determine watch paths
- Support both recursive and non-recursive directory watching based on TypeScript's configuration
- Handle relative paths correctly for directories outside workspace

This ensures svelte-check only watches directories included by the tsconfig, improving performance and avoiding unnecessary file watching.

Author: aewing

packages/language-server/src/plugins/typescript/service.ts

@@ -60,6 +60,7 @@ export interface LanguageServiceContainer {
     getResolvedProjectReferences(): TsConfigInfo[];
     openVirtualDocument(document: Document): void;
     isShimFiles(filePath: string): boolean;
+    getProjectConfig(): ts.ParsedCommandLine;
     dispose(): void;
 }
 
@@ -458,6 +459,7 @@ async function createLanguageService(
         getResolvedProjectReferences,
         openVirtualDocument,
         isShimFiles,
+        getProjectConfig,
         dispose
     };
 
@@ -1249,6 +1251,10 @@ async function createLanguageService(
     function isShimFiles(filePath: string) {
         return svelteTsxFilesToOriginalCasing.has(getCanonicalFileName(normalizePath(filePath)));
     }
+
+    function getProjectConfig() {
+        return projectConfig;
+    }
 }
 
 /**

packages/language-server/src/svelte-check.ts

@@ -353,4 +353,25 @@ export class SvelteCheck {
         }
         return this.lsAndTSDocResolver.getTSService(tsconfigPath);
     }
+
+    /**
+     * Gets the watch directories based on the tsconfig include patterns.
+     * Returns null if no tsconfig is specified.
+     */
+    async getWatchDirectories(): Promise<{ path: string; recursive: boolean }[] | null> {
+        if (!this.options.tsconfig) {
+            return null;
+        }
+        const lsContainer = await this.getLSContainer(this.options.tsconfig);
+        const projectConfig = lsContainer.getProjectConfig();
+        
+        if (!projectConfig.wildcardDirectories) {
+            return null;
+        }
+        
+        return Object.entries(projectConfig.wildcardDirectories).map(([dir, flags]) => ({
+            path: dir,
+            recursive: !!(flags & ts.WatchDirectoryFlags.Recursive)
+        }));
+    }
 }

packages/svelte-check/src/index.ts

@@ -145,47 +145,91 @@ async function getDiagnostics(
 
 class DiagnosticsWatcher {
     private updateDiagnostics: any;
+    private watcher: any;
+    private currentWatchedDirs = new Set<string>();
+    private fileEnding = /\.(svelte|d\.ts|ts|js|jsx|tsx|mjs|cjs|mts|cts)$/;
+    private viteConfigRegex = /vite\.config\.(js|ts)\.timestamp-/;
+    private userIgnored: Array<(path: string) => boolean>;
+    private offset: number;
 
     constructor(
         private workspaceUri: URI,
         private svelteCheck: SvelteCheck,
         private writer: Writer,
         filePathsToIgnore: string[],
-        ignoreInitialAdd: boolean
+        private ignoreInitialAdd: boolean
     ) {
-        const fileEnding = /\.(svelte|d\.ts|ts|js|jsx|tsx|mjs|cjs|mts|cts)$/;
-        const viteConfigRegex = /vite\.config\.(js|ts)\.timestamp-/;
-        const userIgnored = createIgnored(filePathsToIgnore);
-        const offset = workspaceUri.fsPath.length + 1;
+        this.userIgnored = createIgnored(filePathsToIgnore);
+        this.offset = workspaceUri.fsPath.length + 1;
 
-        watch(workspaceUri.fsPath, {
+        // Create watcher with initial paths
+        this.watcher = watch([], {
             ignored: (path, stats) => {
                 if (
                     path.includes('node_modules') ||
                     path.includes('.git') ||
-                    (stats?.isFile() && (!fileEnding.test(path) || viteConfigRegex.test(path)))
+                    (stats?.isFile() && (!this.fileEnding.test(path) || this.viteConfigRegex.test(path)))
                 ) {
                     return true;
                 }
 
-                if (userIgnored.length !== 0) {
-                    path = path.slice(offset);
-                    for (const i of userIgnored) {
-                        if (i(path)) {
+                if (this.userIgnored.length !== 0) {
+                    // Make path relative to workspace for user ignores
+                    const workspaceRelative = path.startsWith(this.workspaceUri.fsPath)
+                        ? path.slice(this.workspaceUri.fsPath.length + 1)
+                        : path;
+                    for (const i of this.userIgnored) {
+                        if (i(workspaceRelative)) {
                             return true;
                         }
                     }
                 }
 
                 return false;
             },
-            ignoreInitial: ignoreInitialAdd
+            ignoreInitial: this.ignoreInitialAdd
         })
             .on('add', (path) => this.updateDocument(path, true))
             .on('unlink', (path) => this.removeDocument(path))
             .on('change', (path) => this.updateDocument(path, false));
 
-        if (ignoreInitialAdd) {
+        this.updateWatchedDirectories();
+    }
+
+    private async updateWatchedDirectories() {
+        const watchDirs = await this.svelteCheck.getWatchDirectories();
+        const dirsToWatch = watchDirs || [{ path: this.workspaceUri.fsPath, recursive: true }];
+        
+        // Apply exclude heuristic to ensure we never watch commonly excluded directories
+        const excludePatterns = ['node_modules', '.git', 'dist', 'build', 'out', '.svelte-kit', 'coverage', '.nyc_output'];
+        const filteredDirs = dirsToWatch.filter(dir => {
+            const dirPath = dir.path.replace(/\\/g, '/');
+            return !excludePatterns.some(pattern => 
+                dirPath.includes(`/${pattern}/`) || 
+                dirPath.endsWith(`/${pattern}`)
+            );
+        });
+        
+        const newDirs = new Set(filteredDirs.map(d => d.path));
+
+        // Fast diff: find directories to add and remove
+        const toAdd = [...newDirs].filter(dir => !this.currentWatchedDirs.has(dir));
+        const toRemove = [...this.currentWatchedDirs].filter(dir => !newDirs.has(dir));
+
+        // Add new directories
+        if (toAdd.length > 0) {
+            this.watcher.add(toAdd);
+        }
+
+        // Remove old directories
+        if (toRemove.length > 0) {
+            this.watcher.unwatch(toRemove);
+        }
+
+        // Update current set
+        this.currentWatchedDirs = newDirs;
+
+        if (this.ignoreInitialAdd) {
             this.scheduleDiagnostics();
         }
     }
@@ -210,10 +254,15 @@ class DiagnosticsWatcher {
         this.scheduleDiagnostics();
     }
 
-    scheduleDiagnostics() {
+    scheduleDiagnostics(updateWatchers = false) {
         clearTimeout(this.updateDiagnostics);
         this.updateDiagnostics = setTimeout(
-            () => getDiagnostics(this.workspaceUri, this.writer, this.svelteCheck),
+            async () => {
+                if (updateWatchers) {
+                    await this.updateWatchedDirectories();
+                }
+                getDiagnostics(this.workspaceUri, this.writer, this.svelteCheck);
+            },
             1000
         );
     }
@@ -264,7 +313,7 @@ parseOptions(async (opts) => {
         };
 
         if (opts.watch) {
-            svelteCheckOptions.onProjectReload = () => watcher.scheduleDiagnostics();
+            svelteCheckOptions.onProjectReload = () => watcher.scheduleDiagnostics(true);
             const watcher = new DiagnosticsWatcher(
                 opts.workspaceUri,
                 new SvelteCheck(opts.workspaceUri.fsPath, svelteCheckOptions),