@sun-asterisk/sunlint 1.3.33 → 1.3.35

package/rules/common/C021_import_organization/index.js

@@ -0,0 +1,83 @@
+/**
+ * C021 Rule Router - Import Organization
+ *
+ * Routes analysis to the appropriate language-specific analyzer.
+ * Supports: TypeScript, JavaScript
+ */
+
+const path = require('path');
+
+class C021Router {
+  constructor() {
+    this.analyzers = new Map();
+    this.ruleId = 'C021';
+  }
+
+  getAnalyzer(language) {
+    const normalizedLang = this.normalizeLanguage(language);
+
+    if (!this.analyzers.has(normalizedLang)) {
+      try {
+        const analyzerPath = path.join(__dirname, normalizedLang, 'analyzer.js');
+        const AnalyzerClass = require(analyzerPath);
+        this.analyzers.set(normalizedLang, new AnalyzerClass());
+      } catch (error) {
+        return null;
+      }
+    }
+
+    return this.analyzers.get(normalizedLang);
+  }
+
+  normalizeLanguage(language) {
+    if (typeof language !== 'string') {
+      return 'typescript';
+    }
+    const languageMap = {
+      'typescript': 'typescript',
+      'javascript': 'typescript',
+      'ts': 'typescript',
+      'js': 'typescript'
+    };
+    return languageMap[language.toLowerCase()] || 'typescript';
+  }
+
+  supportsLanguage(language) {
+    if (typeof language !== 'string') return false;
+    const supported = ['typescript', 'javascript', 'ts', 'js'];
+    return supported.includes(language.toLowerCase());
+  }
+
+  getSupportedLanguages() {
+    return ['typescript', 'javascript'];
+  }
+
+  async analyze(files, language, options = {}) {
+    const analyzer = this.getAnalyzer(language);
+    if (!analyzer) return [];
+    if (typeof analyzer.analyze === 'function') {
+      return analyzer.analyze(files, language, options);
+    }
+    return [];
+  }
+
+  async initialize(semanticEngineOrLanguage = null, semanticEngine = null) {
+    let engine = semanticEngine;
+    let lang = null;
+
+    if (typeof semanticEngineOrLanguage === 'string') {
+      lang = semanticEngineOrLanguage;
+    } else if (semanticEngineOrLanguage && typeof semanticEngineOrLanguage === 'object') {
+      engine = semanticEngineOrLanguage;
+    }
+
+    if (lang) {
+      const analyzer = this.getAnalyzer(lang);
+      if (analyzer && typeof analyzer.initialize === 'function') {
+        await analyzer.initialize(engine);
+      }
+    }
+  }
+}
+
+module.exports = new C021Router();

package/rules/common/C021_import_organization/{ts-morph-analyzer.js → typescript/ts-morph-analyzer.js}

@@ -36,7 +36,6 @@ class C021TsMorphAnalyzer {
       const configData = fs.readFileSync(configPath, 'utf8');
       return JSON.parse(configData).config;
     } catch (error) {
-      console.warn('[C021] Could not load config, using defaults');
       return {
         groups: [
           {

package/rules/common/C023_no_duplicate_variable/config.json

@@ -46,5 +46,10 @@
       "cyclomaticComplexity": 5,
       "nestedDepth": 3
     }
-  }
-}
+  },
+  "languages": [
+    "typescript",
+    "javascript",
+    "dart"
+  ]
+}

package/rules/common/C023_no_duplicate_variable/dart/analyzer.js

@@ -0,0 +1,40 @@
+/**
+ * C023 Dart Analyzer - No Duplicate Variable
+ *
+ * This is a JS wrapper that delegates to DartAnalyzer binary.
+ * Actual implementation: dart_analyzer/lib/rules/C023_no_duplicate_variable.dart
+ */
+
+class DartC023Analyzer {
+  constructor() {
+    this.ruleId = 'C023';
+    this.language = 'dart';
+  }
+
+  getMetadata() {
+    return {
+      ruleId: 'C023',
+      name: 'No Duplicate Variable',
+      language: 'dart',
+      delegateTo: 'dart_analyzer',
+      description: 'Avoid declaring duplicate variables in the same scope'
+    };
+  }
+
+  getConfig() {
+    return {
+      severity: 'warning'
+    };
+  }
+
+  async analyze(files, language, options) {
+    // Delegated to DartAnalyzer binary via heuristic-engine.js
+    return [];
+  }
+
+  supportsLanguage(language) {
+    return language === 'dart';
+  }
+}
+
+module.exports = DartC023Analyzer;

package/rules/common/C023_no_duplicate_variable/index.js

@@ -0,0 +1,83 @@
+/**
+ * C023 Rule Router - No Duplicate Variable
+ *
+ * Routes analysis to the appropriate language-specific analyzer.
+ * Supports: TypeScript, JavaScript
+ */
+
+const path = require('path');
+
+class C023Router {
+  constructor() {
+    this.analyzers = new Map();
+    this.ruleId = 'C023';
+  }
+
+  getAnalyzer(language) {
+    const normalizedLang = this.normalizeLanguage(language);
+
+    if (!this.analyzers.has(normalizedLang)) {
+      try {
+        const analyzerPath = path.join(__dirname, normalizedLang, 'analyzer.js');
+        const AnalyzerClass = require(analyzerPath);
+        this.analyzers.set(normalizedLang, new AnalyzerClass());
+      } catch (error) {
+        return null;
+      }
+    }
+
+    return this.analyzers.get(normalizedLang);
+  }
+
+  normalizeLanguage(language) {
+    if (typeof language !== 'string') {
+      return 'typescript';
+    }
+    const languageMap = {
+      'typescript': 'typescript',
+      'javascript': 'typescript',
+      'ts': 'typescript',
+      'js': 'typescript'
+    };
+    return languageMap[language.toLowerCase()] || 'typescript';
+  }
+
+  supportsLanguage(language) {
+    if (typeof language !== 'string') return false;
+    const supported = ['typescript', 'javascript', 'ts', 'js'];
+    return supported.includes(language.toLowerCase());
+  }
+
+  getSupportedLanguages() {
+    return ['typescript', 'javascript'];
+  }
+
+  async analyze(files, language, options = {}) {
+    const analyzer = this.getAnalyzer(language);
+    if (!analyzer) return [];
+    if (typeof analyzer.analyze === 'function') {
+      return analyzer.analyze(files, language, options);
+    }
+    return [];
+  }
+
+  async initialize(semanticEngineOrLanguage = null, semanticEngine = null) {
+    let engine = semanticEngine;
+    let lang = null;
+
+    if (typeof semanticEngineOrLanguage === 'string') {
+      lang = semanticEngineOrLanguage;
+    } else if (semanticEngineOrLanguage && typeof semanticEngineOrLanguage === 'object') {
+      engine = semanticEngineOrLanguage;
+    }
+
+    if (lang) {
+      const analyzer = this.getAnalyzer(lang);
+      if (analyzer && typeof analyzer.initialize === 'function') {
+        await analyzer.initialize(engine);
+      }
+    }
+  }
+}
+
+module.exports = new C023Router();

package/rules/common/C024_no_scatter_hardcoded_constants/config.json

@@ -46,5 +46,10 @@
       "cyclomaticComplexity": 5,
       "nestedDepth": 3
     }
-  }
-}
+  },
+  "languages": [
+    "typescript",
+    "javascript",
+    "dart"
+  ]
+}

package/rules/common/C024_no_scatter_hardcoded_constants/dart/analyzer.js

@@ -0,0 +1,40 @@
+/**
+ * C024 Dart Analyzer - No Scatter Hardcoded Constants
+ *
+ * This is a JS wrapper that delegates to DartAnalyzer binary.
+ * Actual implementation: dart_analyzer/lib/rules/C024_no_scatter_hardcoded_constants.dart
+ */
+
+class DartC024Analyzer {
+  constructor() {
+    this.ruleId = 'C024';
+    this.language = 'dart';
+  }
+
+  getMetadata() {
+    return {
+      ruleId: 'C024',
+      name: 'No Scatter Hardcoded Constants',
+      language: 'dart',
+      delegateTo: 'dart_analyzer',
+      description: 'Centralize hardcoded constants'
+    };
+  }
+
+  getConfig() {
+    return {
+      severity: 'warning'
+    };
+  }
+
+  async analyze(files, language, options) {
+    // Delegated to DartAnalyzer binary via heuristic-engine.js
+    return [];
+  }
+
+  supportsLanguage(language) {
+    return language === 'dart';
+  }
+}
+
+module.exports = DartC024Analyzer;

package/rules/common/C024_no_scatter_hardcoded_constants/index.js

@@ -0,0 +1,83 @@
+/**
+ * C024 Rule Router - No Scatter Hardcoded Constants
+ *
+ * Routes analysis to the appropriate language-specific analyzer.
+ * Supports: TypeScript, JavaScript
+ */
+
+const path = require('path');
+
+class C024Router {
+  constructor() {
+    this.analyzers = new Map();
+    this.ruleId = 'C024';
+  }
+
+  getAnalyzer(language) {
+    const normalizedLang = this.normalizeLanguage(language);
+
+    if (!this.analyzers.has(normalizedLang)) {
+      try {
+        const analyzerPath = path.join(__dirname, normalizedLang, 'analyzer.js');
+        const AnalyzerClass = require(analyzerPath);
+        this.analyzers.set(normalizedLang, new AnalyzerClass());
+      } catch (error) {
+        return null;
+      }
+    }
+
+    return this.analyzers.get(normalizedLang);
+  }
+
+  normalizeLanguage(language) {
+    if (typeof language !== 'string') {
+      return 'typescript';
+    }
+    const languageMap = {
+      'typescript': 'typescript',
+      'javascript': 'typescript',
+      'ts': 'typescript',
+      'js': 'typescript'
+    };
+    return languageMap[language.toLowerCase()] || 'typescript';
+  }
+
+  supportsLanguage(language) {
+    if (typeof language !== 'string') return false;
+    const supported = ['typescript', 'javascript', 'ts', 'js'];
+    return supported.includes(language.toLowerCase());
+  }
+
+  getSupportedLanguages() {
+    return ['typescript', 'javascript'];
+  }
+
+  async analyze(files, language, options = {}) {
+    const analyzer = this.getAnalyzer(language);
+    if (!analyzer) return [];
+    if (typeof analyzer.analyze === 'function') {
+      return analyzer.analyze(files, language, options);
+    }
+    return [];
+  }
+
+  async initialize(semanticEngineOrLanguage = null, semanticEngine = null) {
+    let engine = semanticEngine;
+    let lang = null;
+
+    if (typeof semanticEngineOrLanguage === 'string') {
+      lang = semanticEngineOrLanguage;
+    } else if (semanticEngineOrLanguage && typeof semanticEngineOrLanguage === 'object') {
+      engine = semanticEngineOrLanguage;
+    }
+
+    if (lang) {
+      const analyzer = this.getAnalyzer(lang);
+      if (analyzer && typeof analyzer.initialize === 'function') {
+        await analyzer.initialize(engine);
+      }
+    }
+  }
+}
+
+module.exports = new C024Router();

package/rules/common/C024_no_scatter_hardcoded_constants/{symbol-based-analyzer.js → typescript/symbol-based-analyzer.js}

@@ -465,7 +465,6 @@ class C024SymbolBasedAnalyzer {
 
       // NEW: Skip if it's a common frontend function argument
       if (this.isFrontendFunctionArgument(literal)) {
-        console.log('Skipping frontend function argument:', literal.getText());
         return;
       }
 

package/rules/common/C029_catch_block_logging/config.json

@@ -1,13 +1,23 @@
 {
   "ruleId": "C029",
   "name": "Catch Block Error Logging",
-  "description": "Mọi catch block phải log nguyên nhân lỗi đầy đủ",
+  "description": "M\u1ecdi catch block ph\u1ea3i log nguy\u00ean nh\u00e2n l\u1ed7i \u0111\u1ea7y \u0111\u1ee7",
   "category": "error-handling",
   "severity": "error",
-  "languages": ["typescript", "dart", "kotlin", "javascript"],
+  "languages": [
+    "typescript",
+    "dart",
+    "kotlin",
+    "javascript"
+  ],
   "version": "1.0.0",
   "status": "activated",
-  "tags": ["error-handling", "logging", "debugging", "monitoring"],
+  "tags": [
+    "error-handling",
+    "logging",
+    "debugging",
+    "monitoring"
+  ],
   "examples": {
     "typescript": {
       "violations": [
@@ -45,7 +55,7 @@
   "configuration": {
     "requiredLoggingMethods": [
       "console.error",
-      "console.log", 
+      "console.log",
       "logger.error",
       "log.error",
       "print",
@@ -56,4 +66,4 @@
     "allowEmptyWhenRethrow": true,
     "checkErrorParameter": true
   }
-}
+}

package/rules/common/C029_catch_block_logging/dart/analyzer.js

@@ -0,0 +1,40 @@
+/**
+ * C029 Dart Analyzer - Catch Block Logging
+ *
+ * This is a JS wrapper that delegates to DartAnalyzer binary.
+ * Actual implementation: dart_analyzer/lib/rules/C029_catch_block_logging.dart
+ */
+
+class DartC029Analyzer {
+  constructor() {
+    this.ruleId = 'C029';
+    this.language = 'dart';
+  }
+
+  getMetadata() {
+    return {
+      ruleId: 'C029',
+      name: 'Catch Block Logging',
+      language: 'dart',
+      delegateTo: 'dart_analyzer',
+      description: 'Ensure proper logging in catch blocks'
+    };
+  }
+
+  getConfig() {
+    return {
+      severity: 'warning'
+    };
+  }
+
+  async analyze(files, language, options) {
+    // Delegated to DartAnalyzer binary via heuristic-engine.js
+    return [];
+  }
+
+  supportsLanguage(language) {
+    return language === 'dart';
+  }
+}
+
+module.exports = DartC029Analyzer;

package/rules/common/C029_catch_block_logging/index.js

@@ -0,0 +1,83 @@
+/**
+ * C029 Rule Router - Catch Block Logging
+ *
+ * Routes analysis to the appropriate language-specific analyzer.
+ * Supports: TypeScript, JavaScript
+ */
+
+const path = require('path');
+
+class C029Router {
+  constructor() {
+    this.analyzers = new Map();
+    this.ruleId = 'C029';
+  }
+
+  getAnalyzer(language) {
+    const normalizedLang = this.normalizeLanguage(language);
+
+    if (!this.analyzers.has(normalizedLang)) {
+      try {
+        const analyzerPath = path.join(__dirname, normalizedLang, 'analyzer.js');
+        const AnalyzerClass = require(analyzerPath);
+        this.analyzers.set(normalizedLang, new AnalyzerClass());
+      } catch (error) {
+        return null;
+      }
+    }
+
+    return this.analyzers.get(normalizedLang);
+  }
+
+  normalizeLanguage(language) {
+    if (typeof language !== 'string') {
+      return 'typescript';
+    }
+    const languageMap = {
+      'typescript': 'typescript',
+      'javascript': 'typescript',
+      'ts': 'typescript',
+      'js': 'typescript'
+    };
+    return languageMap[language.toLowerCase()] || 'typescript';
+  }
+
+  supportsLanguage(language) {
+    if (typeof language !== 'string') return false;
+    const supported = ['typescript', 'javascript', 'ts', 'js'];
+    return supported.includes(language.toLowerCase());
+  }
+
+  getSupportedLanguages() {
+    return ['typescript', 'javascript'];
+  }
+
+  async analyze(files, language, options = {}) {
+    const analyzer = this.getAnalyzer(language);
+    if (!analyzer) return [];
+    if (typeof analyzer.analyze === 'function') {
+      return analyzer.analyze(files, language, options);
+    }
+    return [];
+  }
+
+  async initialize(semanticEngineOrLanguage = null, semanticEngine = null) {
+    let engine = semanticEngine;
+    let lang = null;
+
+    if (typeof semanticEngineOrLanguage === 'string') {
+      lang = semanticEngineOrLanguage;
+    } else if (semanticEngineOrLanguage && typeof semanticEngineOrLanguage === 'object') {
+      engine = semanticEngineOrLanguage;
+    }
+
+    if (lang) {
+      const analyzer = this.getAnalyzer(lang);
+      if (analyzer && typeof analyzer.initialize === 'function') {
+        await analyzer.initialize(engine);
+      }
+    }
+  }
+}
+
+module.exports = new C029Router();

package/rules/common/C030_use_custom_error_classes/config.json

@@ -0,0 +1,28 @@
+{
+  "ruleId": "C030",
+  "name": "Use Custom Error Classes",
+  "description": "Use custom error classes instead of generic Error",
+  "category": "error-handling",
+  "severity": "warning",
+  "languages": [
+    "typescript",
+    "javascript",
+    "dart"
+  ],
+  "version": "1.0.0",
+  "status": "stable",
+  "tags": [
+    "error-handling",
+    "custom-errors",
+    "best-practices"
+  ],
+  "config": {},
+  "examples": {
+    "violations": [],
+    "valid": []
+  },
+  "fixes": {
+    "autoFixable": false,
+    "suggestions": []
+  }
+}

package/rules/common/C030_use_custom_error_classes/dart/analyzer.js

@@ -0,0 +1,40 @@
+/**
+ * C030 Dart Analyzer - Use Custom Error Classes
+ *
+ * This is a JS wrapper that delegates to DartAnalyzer binary.
+ * Actual implementation: dart_analyzer/lib/rules/C030_use_custom_error_classes.dart
+ */
+
+class DartC030Analyzer {
+  constructor() {
+    this.ruleId = 'C030';
+    this.language = 'dart';
+  }
+
+  getMetadata() {
+    return {
+      ruleId: 'C030',
+      name: 'Use Custom Error Classes',
+      language: 'dart',
+      delegateTo: 'dart_analyzer',
+      description: 'Use custom error classes instead of generic errors'
+    };
+  }
+
+  getConfig() {
+    return {
+      severity: 'warning'
+    };
+  }
+
+  async analyze(files, language, options) {
+    // Delegated to DartAnalyzer binary via heuristic-engine.js
+    return [];
+  }
+
+  supportsLanguage(language) {
+    return language === 'dart';
+  }
+}
+
+module.exports = DartC030Analyzer;

package/rules/common/C030_use_custom_error_classes/index.js

@@ -0,0 +1,83 @@
+/**
+ * C030 Rule Router - Use Custom Error Classes
+ *
+ * Routes analysis to the appropriate language-specific analyzer.
+ * Supports: TypeScript, JavaScript
+ */
+
+const path = require('path');
+
+class C030Router {
+  constructor() {
+    this.analyzers = new Map();
+    this.ruleId = 'C030';
+  }
+
+  getAnalyzer(language) {
+    const normalizedLang = this.normalizeLanguage(language);
+
+    if (!this.analyzers.has(normalizedLang)) {
+      try {
+        const analyzerPath = path.join(__dirname, normalizedLang, 'analyzer.js');
+        const AnalyzerClass = require(analyzerPath);
+        this.analyzers.set(normalizedLang, new AnalyzerClass());
+      } catch (error) {
+        return null;
+      }
+    }
+
+    return this.analyzers.get(normalizedLang);
+  }
+
+  normalizeLanguage(language) {
+    if (typeof language !== 'string') {
+      return 'typescript';
+    }
+    const languageMap = {
+      'typescript': 'typescript',
+      'javascript': 'typescript',
+      'ts': 'typescript',
+      'js': 'typescript'
+    };
+    return languageMap[language.toLowerCase()] || 'typescript';
+  }
+
+  supportsLanguage(language) {
+    if (typeof language !== 'string') return false;
+    const supported = ['typescript', 'javascript', 'ts', 'js'];
+    return supported.includes(language.toLowerCase());
+  }
+
+  getSupportedLanguages() {
+    return ['typescript', 'javascript'];
+  }
+
+  async analyze(files, language, options = {}) {
+    const analyzer = this.getAnalyzer(language);
+    if (!analyzer) return [];
+    if (typeof analyzer.analyze === 'function') {
+      return analyzer.analyze(files, language, options);
+    }
+    return [];
+  }
+
+  async initialize(semanticEngineOrLanguage = null, semanticEngine = null) {
+    let engine = semanticEngine;
+    let lang = null;
+
+    if (typeof semanticEngineOrLanguage === 'string') {
+      lang = semanticEngineOrLanguage;
+    } else if (semanticEngineOrLanguage && typeof semanticEngineOrLanguage === 'object') {
+      engine = semanticEngineOrLanguage;
+    }
+
+    if (lang) {
+      const analyzer = this.getAnalyzer(lang);
+      if (analyzer && typeof analyzer.initialize === 'function') {
+        await analyzer.initialize(engine);
+      }
+    }
+  }
+}
+
+module.exports = new C030Router();