added css class definition searching

Author: Andcool-Systems

vscode-ext/README.md

@@ -6,7 +6,8 @@ A tool for analyzing CSS modules in Next.js projects. The linter detects **unuse
 - Project-wide analysis with warnings displayed in the editor  
 - High performance thanks to Rust-based implementation  
 - Support for `import aliases` from `tsconfig.json`  
-- Ability to ignore specific warnings  
+- Ability to ignore specific warnings
+- Find definitions for your CSS classes  
 
 ## 🔹 Usage  
 Linting runs automatically **on file save**, and warnings are displayed in the workspace.  

vscode-ext/package.json

@@ -2,7 +2,7 @@
   "name": "next-css-lint",
   "displayName": "Next.Js CSS linter",
   "description": "Displaying unused CSS classes in Next.Js projects",
-  "version": "1.7.2",
+  "version": "1.7.3",
   "license": "MIT",
   "repository": "https://github.com/Andcool-Systems/css-linter",
   "author": {

vscode-ext/src/extension.ts

@@ -1,8 +1,9 @@
 import * as vscode from 'vscode';
 import { exec } from 'child_process';
-import { join } from 'path';
+import { join, resolve } from 'path';
 import { binaries, install } from './installer';
 import os from 'os';
+import { existsSync, readFileSync } from 'fs';
 
 export function activate(context: vscode.ExtensionContext) {
     const diagnosticCollection = vscode.languages.createDiagnosticCollection('css-linter-diags');
@@ -89,6 +90,13 @@ export function activate(context: vscode.ExtensionContext) {
             run_diag();
         })
         .catch(e => console.error(`[CSS-linter][ERROR]: ${e}`));
+
+    const provider = vscode.languages.registerDefinitionProvider(
+        { scheme: 'file', language: 'typescriptreact' },
+        new CssModuleDefinitionProvider()
+    );
+
+    context.subscriptions.push(provider);
 }
 
 class CssFixProvider implements vscode.CodeActionProvider {
@@ -123,5 +131,101 @@ class CssFixProvider implements vscode.CodeActionProvider {
     }
 }
 
+export class CssModuleDefinitionProvider implements vscode.DefinitionProvider {
+    async provideDefinition(
+        document: vscode.TextDocument,
+        position: vscode.Position,
+        token: vscode.CancellationToken
+    ): Promise<vscode.Definition | null> {
+        const wordRange = document.getWordRangeAtPosition(position);
+        if (!wordRange) return null;
+
+        const word = document.getText(wordRange);
+        const text = document.getText();
+        const lineText = document.lineAt(position.line).text;
+
+        const regex = /(\w+)\.(\w+)/g;
+        let match;
+        const matches: { objectName: string; propertyName: string }[] = [];
+
+        while ((match = regex.exec(lineText)) !== null) {
+            matches.push({ objectName: match[1], propertyName: match[2] });
+        }
+
+        const matchData = matches.find(m => m.propertyName === word);
+        if (!matchData) return null;
+
+        const { objectName, propertyName } = matchData;
+        if (propertyName !== word) return null;
+
+        const importRegex = new RegExp(`import\\s+${objectName}\\s+from\\s+['"](.*?)['"]`);
+        const importMatch = text.match(importRegex);
+        if (!importMatch) return null;
+
+        const importPath = importMatch[1];
+        const resolvedPath = this.resolveImportPath(document, importPath);
+        if (!resolvedPath) return null;
+
+        const allowedExtensions = ['.module.css', '.module.scss'];
+        if (!allowedExtensions.some(ext => resolvedPath.endsWith(ext))) return null;
+
+        const fileContent = readFileSync(resolvedPath, 'utf-8');
+        const lines = fileContent.split('\n');
+
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].includes(`.${propertyName}`)) {
+                const definitionUri = vscode.Uri.file(resolvedPath);
+                const definitionPosition = new vscode.Position(i, 0);
+                return new vscode.Location(definitionUri, definitionPosition);
+            }
+        }
+
+        return null;
+    }
+
+    private resolveImportPath(document: vscode.TextDocument, importPath: string): string | null {
+        const workspacePath = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+        if (!workspacePath) return null;
+
+        const tsConfigPath = join(workspacePath, 'tsconfig.json');
+        let aliasMap: Record<string, string> = {};
+        if (existsSync(tsConfigPath)) {
+            const tsConfig = JSON.parse(readFileSync(tsConfigPath, 'utf-8'));
+            if (tsConfig.compilerOptions?.paths) {
+                aliasMap = this.parseTsConfigPaths(tsConfig.compilerOptions.paths, workspacePath);
+            }
+        }
+
+        for (const alias in aliasMap) {
+            if (importPath.startsWith(alias)) {
+                return importPath.replace(alias, aliasMap[alias]);
+            }
+        }
+
+        if (importPath.startsWith('.')) {
+            const currentDir = join(document.uri.fsPath, '..');
+            return resolve(currentDir, importPath);
+        }
+
+        return join(workspacePath, importPath);
+    }
+
+    private parseTsConfigPaths(
+        paths: Record<string, string[]>,
+        workspacePath: string
+    ): Record<string, string> {
+        const aliasMap: Record<string, string> = {};
+        for (const alias in paths) {
+            const targetPaths = paths[alias];
+            if (targetPaths.length > 0) {
+                const cleanedAlias = alias.replace(/\*$/, ''); // "@/*" → "@/"
+                const cleanedPath = targetPaths[0].replace(/\*$/, ''); // "./src/*" → "./src/"
+                aliasMap[cleanedAlias] = join(workspacePath, cleanedPath);
+            }
+        }
+        return aliasMap;
+    }
+}
+
 export function deactivate() {}