@sun-asterisk/sunlint 1.3.32 → 1.3.34

package/rules/common/C070_no_real_time_tests/config.json

@@ -11,8 +11,16 @@
     "fallback": "heuristic"
   },
   "patterns": {
-    "include": ["**/*.test.*", "**/*.spec.*", "**/__tests__/**"],
-    "exclude": ["**/performance/**", "**/benchmarks/**", "**/e2e/**"]
+    "include": [
+      "**/*.test.*",
+      "**/*.spec.*",
+      "**/__tests__/**"
+    ],
+    "exclude": [
+      "**/performance/**",
+      "**/benchmarks/**",
+      "**/e2e/**"
+    ]
   },
   "options": {
     "timerApis": {
@@ -38,16 +46,29 @@
     },
     "fakeTimerDetectors": {
       "jest_vitest": [
-        "jest\\.useFakeTimers\\(\\)", "vi\\.useFakeTimers\\(\\)",
-        "jest\\.advanceTimersByTime\\s*\\(", "vi\\.advanceTimersByTime\\s*\\(",
-        "jest\\.runAllTimers\\(\\)", "vi\\.runAllTimers\\(\\)"
+        "jest\\.useFakeTimers\\(\\)",
+        "vi\\.useFakeTimers\\(\\)",
+        "jest\\.advanceTimersByTime\\s*\\(",
+        "vi\\.advanceTimersByTime\\s*\\(",
+        "jest\\.runAllTimers\\(\\)",
+        "vi\\.runAllTimers\\(\\)"
       ],
-      "rxjs": ["new TestScheduler(*)"]
+      "rxjs": [
+        "new TestScheduler(*)"
+      ]
     },
     "busyPollingDetectors": {
-      "ts_js": ["Date.now()", "new Date()"],
-      "java": ["System.currentTimeMillis()", "Instant.now()"],
-      "go": ["time.Now()"]
+      "ts_js": [
+        "Date.now()",
+        "new Date()"
+      ],
+      "java": [
+        "System.currentTimeMillis()",
+        "Instant.now()"
+      ],
+      "go": [
+        "time.Now()"
+      ]
     },
     "policy": {
       "forbidRealSleeps": true,
@@ -57,7 +78,10 @@
       "allowAnnotatedPerfTests": true
     },
     "allowAnnotations": [
-      "@perf", "@benchmark", "@allow-real-time", "// @allow-real-time"
+      "@perf",
+      "@benchmark",
+      "@allow-real-time",
+      "// @allow-real-time"
     ],
     "suggestions": {
       "ts_js": [
@@ -74,5 +98,10 @@
         "Avoid time.Sleep; wait on channels/conditions/events instead."
       ]
     }
-  }
-}
+  },
+  "languages": [
+    "typescript",
+    "javascript",
+    "dart"
+  ]
+}

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

@@ -0,0 +1,40 @@
+/**
+ * C070 Dart Analyzer - No Real Time Tests
+ *
+ * This is a JS wrapper that delegates to DartAnalyzer binary.
+ * Actual implementation: dart_analyzer/lib/rules/C070_no_real_time_tests.dart
+ */
+
+class DartC070Analyzer {
+  constructor() {
+    this.ruleId = 'C070';
+    this.language = 'dart';
+  }
+
+  getMetadata() {
+    return {
+      ruleId: 'C070',
+      name: 'No Real Time Tests',
+      language: 'dart',
+      delegateTo: 'dart_analyzer',
+      description: 'Avoid tests that depend on real time'
+    };
+  }
+
+  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 = DartC070Analyzer;

package/rules/common/C070_no_real_time_tests/index.js

@@ -0,0 +1,83 @@
+/**
+ * C070 Rule Router - No Real Time Tests
+ *
+ * Routes analysis to the appropriate language-specific analyzer.
+ * Supports: TypeScript, JavaScript
+ */
+
+const path = require('path');
+
+class C070Router {
+  constructor() {
+    this.analyzers = new Map();
+    this.ruleId = 'C070';
+  }
+
+  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 C070Router();

package/rules/common/C072_single_test_behavior/config.json

@@ -0,0 +1,28 @@
+{
+  "ruleId": "C072",
+  "name": "Single Test Behavior",
+  "description": "Each test should verify a single behavior",
+  "category": "testing",
+  "severity": "info",
+  "languages": [
+    "typescript",
+    "javascript",
+    "dart"
+  ],
+  "version": "1.0.0",
+  "status": "stable",
+  "tags": [
+    "testing",
+    "best-practices",
+    "single-responsibility"
+  ],
+  "config": {},
+  "examples": {
+    "violations": [],
+    "valid": []
+  },
+  "fixes": {
+    "autoFixable": false,
+    "suggestions": []
+  }
+}

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

@@ -0,0 +1,40 @@
+/**
+ * C072 Dart Analyzer - Single Test Behavior
+ *
+ * This is a JS wrapper that delegates to DartAnalyzer binary.
+ * Actual implementation: dart_analyzer/lib/rules/C072_single_test_behavior.dart
+ */
+
+class DartC072Analyzer {
+  constructor() {
+    this.ruleId = 'C072';
+    this.language = 'dart';
+  }
+
+  getMetadata() {
+    return {
+      ruleId: 'C072',
+      name: 'Single Test Behavior',
+      language: 'dart',
+      delegateTo: 'dart_analyzer',
+      description: 'Each test should verify a single behavior'
+    };
+  }
+
+  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 = DartC072Analyzer;

package/rules/common/C072_single_test_behavior/index.js

@@ -0,0 +1,83 @@
+/**
+ * C072 Rule Router - Single Test Behavior
+ *
+ * Routes analysis to the appropriate language-specific analyzer.
+ * Supports: TypeScript, JavaScript
+ */
+
+const path = require('path');
+
+class C072Router {
+  constructor() {
+    this.analyzers = new Map();
+    this.ruleId = 'C072';
+  }
+
+  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 C072Router();

package/rules/common/C073_validate_required_config_on_startup/config.json

@@ -5,33 +5,103 @@
   "description": "C073 - Validate mandatory configuration at startup and fail fast on invalid/missing values.",
   "severity": "error",
   "enabled": true,
-  "semantic": { "enabled": true, "priority": "high", "fallback": "heuristic" },
+  "semantic": {
+    "enabled": true,
+    "priority": "high",
+    "fallback": "heuristic"
+  },
   "patterns": {
-    "include": ["**/*.ts","**/*.tsx","**/*.js","**/*.jsx","**/*.java","**/*.go"],
-    "exclude": ["**/*.test.*","**/*.spec.*","**/__tests__/**","**/fixtures/**","**/examples/**"]
+    "include": [
+      "**/*.ts",
+      "**/*.tsx",
+      "**/*.js",
+      "**/*.jsx",
+      "**/*.java",
+      "**/*.go"
+    ],
+    "exclude": [
+      "**/*.test.*",
+      "**/*.spec.*",
+      "**/__tests__/**",
+      "**/fixtures/**",
+      "**/examples/**"
+    ]
   },
   "options": {
     "configModules": {
-      "typescript": ["src/config/**","**/config/**","**/bootstrap/**","**/main.ts"],
-      "java": ["**/config/**","**/Configuration/**","**/Application.java","**/*Application.java"],
-      "go": ["cmd/**","**/config/**","**/main.go"]
+      "typescript": [
+        "src/config/**",
+        "**/config/**",
+        "**/bootstrap/**",
+        "**/main.ts"
+      ],
+      "java": [
+        "**/config/**",
+        "**/Configuration/**",
+        "**/Application.java",
+        "**/*Application.java"
+      ],
+      "go": [
+        "cmd/**",
+        "**/config/**",
+        "**/main.go"
+      ]
     },
     "envAccessors": {
-      "typescript": ["process.env.*"],
-      "java": ["System.getenv(*)","System.getProperty(*)"],
-      "go": ["os.Getenv(*)"]
+      "typescript": [
+        "process.env.*"
+      ],
+      "java": [
+        "System.getenv(*)",
+        "System.getProperty(*)"
+      ],
+      "go": [
+        "os.Getenv(*)"
+      ]
     },
     "schemaDetectors": {
-      "typescript": ["zod","joi","yup","envalid","dotenv-safe","class-validator"],
-      "java": ["@ConfigurationProperties","@Validated","jakarta.validation","hibernate.validator"],
-      "go": ["github.com/kelseyhightower/envconfig","github.com/spf13/viper"]
+      "typescript": [
+        "zod",
+        "joi",
+        "yup",
+        "envalid",
+        "dotenv-safe",
+        "class-validator"
+      ],
+      "java": [
+        "@ConfigurationProperties",
+        "@Validated",
+        "jakarta.validation",
+        "hibernate.validator"
+      ],
+      "go": [
+        "github.com/kelseyhightower/envconfig",
+        "github.com/spf13/viper"
+      ]
     },
     "failFastSignals": {
-      "typescript": ["throw new Error(*)","process.exit(1)"],
-      "java": ["throw new RuntimeException(*)","SpringApplication.exit(*)","System.exit(1)"],
-      "go": ["log.Fatal(*)","panic(*)","os.Exit(1)"]
+      "typescript": [
+        "throw new Error(*)",
+        "process.exit(1)"
+      ],
+      "java": [
+        "throw new RuntimeException(*)",
+        "SpringApplication.exit(*)",
+        "System.exit(1)"
+      ],
+      "go": [
+        "log.Fatal(*)",
+        "panic(*)",
+        "os.Exit(1)"
+      ]
     },
-    "dangerousDefaults": ["|| ''","|| 0","|| 'http://localhost'","?: ''","?: 0"],
+    "dangerousDefaults": [
+      "|| ''",
+      "|| 0",
+      "|| 'http://localhost'",
+      "?: ''",
+      "?: 0"
+    ],
     "thresholds": {
       "maxEnvReadsOutsideConfig": 3
     },
@@ -42,5 +112,10 @@
       "flagDangerousDefaults": true,
       "requireStartupConnectivityChecks": true
     }
-  }
-}
+  },
+  "languages": [
+    "typescript",
+    "javascript",
+    "dart"
+  ]
+}

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

@@ -0,0 +1,40 @@
+/**
+ * C073 Dart Analyzer - Validate Required Config On Startup
+ *
+ * This is a JS wrapper that delegates to DartAnalyzer binary.
+ * Actual implementation: dart_analyzer/lib/rules/C073_validate_required_config_on_startup.dart
+ */
+
+class DartC073Analyzer {
+  constructor() {
+    this.ruleId = 'C073';
+    this.language = 'dart';
+  }
+
+  getMetadata() {
+    return {
+      ruleId: 'C073',
+      name: 'Validate Required Config On Startup',
+      language: 'dart',
+      delegateTo: 'dart_analyzer',
+      description: 'Validate required configuration on application startup'
+    };
+  }
+
+  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 = DartC073Analyzer;

package/rules/common/C073_validate_required_config_on_startup/index.js

@@ -0,0 +1,83 @@
+/**
+ * C073 Rule Router - Validate Required Config On Startup
+ *
+ * Routes analysis to the appropriate language-specific analyzer.
+ * Supports: TypeScript, JavaScript
+ */
+
+const path = require('path');
+
+class C073Router {
+  constructor() {
+    this.analyzers = new Map();
+    this.ruleId = 'C073';
+  }
+
+  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 C073Router();

package/rules/common/C073_validate_required_config_on_startup/{analyzer.js → typescript/analyzer.js}

@@ -28,7 +28,6 @@ class C073ConfigValidationAnalyzer {
       this.thresholds = this.options.thresholds || {};
       this.policy = this.options.policy || {};
     } catch (error) {
-      console.warn(`[C073] Could not load config: ${error.message}`);
       this.options = {};
       this.configModules = {};
       this.envAccessors = {};

package/rules/common/C075_explicit_return_types/config.json

@@ -0,0 +1,28 @@
+{
+  "ruleId": "C075",
+  "name": "Explicit Return Types",
+  "description": "Functions should have explicit return type annotations",
+  "category": "typescript",
+  "severity": "info",
+  "languages": [
+    "typescript",
+    "javascript",
+    "dart"
+  ],
+  "version": "1.0.0",
+  "status": "stable",
+  "tags": [
+    "typescript",
+    "types",
+    "explicit"
+  ],
+  "config": {},
+  "examples": {
+    "violations": [],
+    "valid": []
+  },
+  "fixes": {
+    "autoFixable": false,
+    "suggestions": []
+  }
+}

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

@@ -0,0 +1,40 @@
+/**
+ * C075 Dart Analyzer - Explicit Return Types
+ *
+ * This is a JS wrapper that delegates to DartAnalyzer binary.
+ * Actual implementation: dart_analyzer/lib/rules/C075_explicit_return_types.dart
+ */
+
+class DartC075Analyzer {
+  constructor() {
+    this.ruleId = 'C075';
+    this.language = 'dart';
+  }
+
+  getMetadata() {
+    return {
+      ruleId: 'C075',
+      name: 'Explicit Return Types',
+      language: 'dart',
+      delegateTo: 'dart_analyzer',
+      description: 'Functions should have explicit return type annotations'
+    };
+  }
+
+  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 = DartC075Analyzer;