Watch only for extension / watch mode

Author: fongandrew

README.md

@@ -58,6 +58,14 @@ The plugin supports the following configuration options:
 
     // Glob patterns for files to ignore (default: ['**/node_modules/**', '**/dist/**', '**/out/**', '**/build/**'])
     ignore: ['**/node_modules/**', '**/dist/**', '**/out/**', '**/build/**']
+
+    // Whether to enable the file watcher for changes to CSS files. This is
+    // useful when used as part of an editor plugin but can cause CI jobs
+    // to hang. By default, the watcher is enabled only if the running script
+    // has `serve` or `watch` in its name (the VSCode ESLint extension is
+    // named `eslintServer`). This behavior can be overridden by running
+    // your own check and setting this option to true or false accordingly.
+    watch: 'auto'
   }]
 }
 ```

dist/rules/no-unknown-class.d.ts

@@ -8,6 +8,11 @@ export interface PluginOptions {
     cssFiles?: string[];
     /** Patterns to ignore when searching for CSS files */
     ignore?: string[];
+    /**
+     * Enable watcher? Defaults to "auto", which only runs if the script namae has "watch"
+     * or "serve" in it (VSCode's extension is named eslintServer).
+     */
+    watch?: boolean | 'auto';
 }
 declare const rule: RuleModule<'unknownClass', [PluginOptions]>;
 export default rule;

dist/rules/no-unknown-class.js

@@ -7,6 +7,7 @@ const DEFAULT_OPTIONS = {
     classFunctions: ['clsx', 'classNames', 'cx'],
     cssFiles: ['**/*.css'],
     ignore: ['**/node_modules/**', '**/dist/**', '**/out/**', '**/build/**'],
+    watch: 'auto',
 };
 const rule = {
     // Not sure why we need to do this since it doesn't show up on context.options anyways,
@@ -52,7 +53,15 @@ const rule = {
         };
         // Initialize watcher if not already done
         if (!cssWatcher) {
-            cssWatcher = new file_watcher_1.CssWatcher(options.cssFiles, options.ignore);
+            const shouldWatch = (() => {
+                var _a, _b;
+                if (options.watch === 'auto') {
+                    const script = (_b = (_a = process.argv[1]) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : '';
+                    return script.includes('watch') || script.includes('serve');
+                }
+                return options.watch;
+            })();
+            cssWatcher = new file_watcher_1.CssWatcher(options.cssFiles, options.ignore, shouldWatch);
         }
         /** Helper to check if a class exists in our CSS files */
         const validate = (className, node) => {

dist/utils/file-watcher.d.ts

@@ -3,8 +3,9 @@ export declare class CssWatcher {
     private watcher;
     private patterns;
     private ignorePatterns;
-    constructor(patterns?: string[], ignore?: string[]);
-    private setupWatcher;
+    private enableWatch;
+    constructor(patterns?: string[], ignore?: string[], enableWatch?: boolean);
+    private maybeSetupWatcher;
     private updateClassesForFile;
     private initialScan;
     hasClass(className: string): boolean;

dist/utils/file-watcher.js

@@ -9,7 +9,7 @@ const chokidar_1 = __importDefault(require("chokidar"));
 const css_extractor_1 = require("./css-extractor");
 const micromatch_1 = __importDefault(require("micromatch"));
 class CssWatcher {
-    constructor(patterns = ['**/*.css'], ignore = ['**/node_modules/**', '**/dist/**', '**/out/**', '**/build/**']) {
+    constructor(patterns = ['**/*.css'], ignore = ['**/node_modules/**', '**/dist/**', '**/out/**', '**/build/**'], enableWatch = true) {
         this.state = {
             fileClasses: new Map(),
             lastUpdate: 0,
@@ -18,11 +18,14 @@ class CssWatcher {
         this.patterns = patterns;
         // Ignore hidden files by default
         this.ignorePatterns = ['**/.*', ...ignore];
+        this.enableWatch = enableWatch;
         const cwd = process.cwd();
-        this.setupWatcher(cwd);
+        this.maybeSetupWatcher(cwd);
         this.initialScan(cwd);
     }
-    setupWatcher(cwd) {
+    maybeSetupWatcher(cwd) {
+        if (!this.enableWatch)
+            return;
         this.watcher = chokidar_1.default.watch(cwd, {
             persistent: true,
             ignoreInitial: true, // We need to do our initial scan synchronously

src/rules/no-unknown-class.ts

@@ -11,6 +11,11 @@ export interface PluginOptions {
 	cssFiles?: string[];
 	/** Patterns to ignore when searching for CSS files */
 	ignore?: string[];
+	/**
+	 * Enable watcher? Defaults to "auto", which only runs if the script namae has "watch"
+	 * or "serve" in it (VSCode's extension is named eslintServer).
+	 */
+	watch?: boolean | 'auto';
 }
 
 let cssWatcher: CssWatcher | null = null;
@@ -20,6 +25,7 @@ const DEFAULT_OPTIONS: PluginOptions = {
 	classFunctions: ['clsx', 'classNames', 'cx'],
 	cssFiles: ['**/*.css'],
 	ignore: ['**/node_modules/**', '**/dist/**', '**/out/**', '**/build/**'],
+	watch: 'auto',
 };
 
 const rule: RuleModule<'unknownClass', [PluginOptions]> = {
@@ -68,7 +74,14 @@ const rule: RuleModule<'unknownClass', [PluginOptions]> = {
 
 		// Initialize watcher if not already done
 		if (!cssWatcher) {
-			cssWatcher = new CssWatcher(options.cssFiles, options.ignore);
+			const shouldWatch = (() => {
+				if (options.watch === 'auto') {
+					const script = process.argv[1]?.toLowerCase() ?? '';
+					return script.includes('watch') || script.includes('serve');
+				}
+				return options.watch;
+			})();
+			cssWatcher = new CssWatcher(options.cssFiles, options.ignore, shouldWatch);
 		}
 
 		/** Helper to check if a class exists in our CSS files */

src/utils/file-watcher.ts

@@ -12,21 +12,25 @@ export class CssWatcher {
 	private watcher: FSWatcher | null = null;
 	private patterns: string[];
 	private ignorePatterns: string[];
+	private enableWatch: boolean;
 
 	constructor(
 		patterns: string[] = ['**/*.css'],
 		ignore: string[] = ['**/node_modules/**', '**/dist/**', '**/out/**', '**/build/**'],
+		enableWatch = true,
 	) {
 		this.patterns = patterns;
 		// Ignore hidden files by default
 		this.ignorePatterns = ['**/.*', ...ignore];
+		this.enableWatch = enableWatch;
 
 		const cwd = process.cwd();
-		this.setupWatcher(cwd);
+		this.maybeSetupWatcher(cwd);
 		this.initialScan(cwd);
 	}
 
-	private setupWatcher(cwd: string) {
+	private maybeSetupWatcher(cwd: string) {
+		if (!this.enableWatch) return;
 		this.watcher = chokidar.watch(cwd, {
 			persistent: true,
 			ignoreInitial: true, // We need to do our initial scan synchronously