added disabling checks

Author: Andcool-Systems

vscode-ext/package.json

@@ -2,7 +2,7 @@
   "name": "next-css-lint",
   "displayName": "Next.Js CSS linter",
   "description": "Display unused CSS classes in Next.Js projects and search for class definitions",
-  "version": "1.7.5",
+  "version": "1.7.6",
   "license": "MIT",
   "repository": "https://github.com/Andcool-Systems/css-linter",
   "author": {
@@ -14,6 +14,31 @@
   "engines": {
     "vscode": "^1.92.0"
   },
+  "contributes": {
+    "commands": [
+      {
+        "command": "next-css-lint.enable",
+        "title": "Next.Js CSS linter: Enable"
+      },
+      {
+        "command": "next-css-lint.disable",
+        "title": "Next.Js CSS linter: Disable"
+      }
+    ],
+    "configuration": [
+      {
+        "title": "Next.Js CSS linter configuration",
+        "type": "object",
+        "properties": {
+          "next-css-lint.enabled": {
+            "type": "boolean",
+            "default": true,
+            "description": "Enable Next.Js CSS linter in current workplace"
+          }
+        }
+      }
+    ]
+  },
   "categories": [
     "Linters"
   ],

vscode-ext/src/definition.provider.ts

@@ -0,0 +1,102 @@
+import { existsSync, readFileSync } from 'fs';
+import { join, resolve } from 'path';
+import * as vscode from 'vscode';
+
+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');
+
+        const definitions: vscode.Location[] = [];
+
+        for (let i = 0; i < lines.length; i++) {
+            let line = lines[i].trimStart();
+            if (line.match(new RegExp(`\\.${propertyName}(?![a-zA-Z0-9-_])`))) {
+                const definitionUri = vscode.Uri.file(resolvedPath);
+                const definitionPosition = new vscode.Position(i, 0);
+                definitions.push(new vscode.Location(definitionUri, definitionPosition));
+            }
+        }
+
+        return definitions;
+    }
+
+    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;
+    }
+}

vscode-ext/src/diagnostics.ts

@@ -0,0 +1,56 @@
+import { exec } from 'child_process';
+import * as vscode from 'vscode';
+import { join } from 'path';
+
+export const run_diag = (exec_path: string, diagnosticCollection: vscode.DiagnosticCollection) => {
+    const workspacePath = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+    if (!workspacePath) {
+        return;
+    }
+
+    exec(`${exec_path} --lint ${workspacePath} --minify`, (error, stdout, stderr) => {
+        if (error || stderr) {
+            console.error(`[CSS-linter][ERROR]: ${error || stderr}`);
+            return;
+        }
+
+        console.info(`[CSS-linter][INFO]: ${stdout}`);
+        diagnosticCollection.clear();
+
+        const error_lines = stdout.split('\n');
+        if (error_lines.length === 0) return;
+
+        const diagnosticsMap: Map<string, vscode.Diagnostic[]> = new Map();
+        for (let e_line of error_lines) {
+            let frags = e_line.split(':');
+            if (frags.length < 4) {
+                continue;
+            }
+
+            const filePath = frags[0];
+            const line = parseInt(frags[1]) - 1;
+            const col = parseInt(frags[2]);
+            const len = parseInt(frags[3]);
+            const message = frags[4];
+
+            const range = new vscode.Range(line, col, line, col + len);
+            const diagnostic = new vscode.Diagnostic(
+                range,
+                message,
+                vscode.DiagnosticSeverity.Warning
+            );
+            diagnostic.source = 'next-css-linter';
+
+            const diagnostics = diagnosticsMap.get(filePath) || [];
+            diagnostics.push(diagnostic);
+            diagnosticsMap.set(filePath, diagnostics);
+        }
+
+        diagnosticsMap.forEach((diags, file) => {
+            const fileUri = vscode.Uri.file(
+                join(workspacePath, file.replace(new RegExp(`^./`), ''))
+            );
+            diagnosticCollection.set(fileUri, diags);
+        });
+    });
+};