@sun-asterisk/sunlint 1.0.5

package/eslint-integration/eslint-plugin-custom/t026-limit-nested-generics.js

@@ -0,0 +1,377 @@
+/**
+ * Custom ESLint rule for: T026 – Limit deeply nested generics
+ * Rule ID: custom/t026
+ * Purpose: Prevent deeply nested generic type parameters to maintain type readability and reduce cognitive load
+ * 
+ * Following Vietnamese Coding Standards:
+ * - Rule C005: Each function should do one thing (this rule focuses solely on generic nesting)
+ * - Rule C015: Use domain language in naming (clear error messages in both English and Vietnamese)
+ */
+
+"use strict";
+
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Limit deeply nested generics to maintain type readability",
+      category: "TypeScript",
+      recommended: true,
+    },
+    fixable: null,
+    schema: [
+      {
+        type: "object",
+        properties: {
+          maxDepth: {
+            type: "integer",
+            minimum: 1,
+            description: "Maximum allowed depth of nested generics (default: 3)"
+          },
+          allowUtilityTypes: {
+            type: "boolean",
+            description: "Whether to allow deeper nesting in utility types like Partial, Pick, etc. (default: true)"
+          },
+          exemptedTypeNames: {
+            type: "array",
+            items: { type: "string" },
+            description: "List of type names that are exempt from the depth check"
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      tooDeepNesting: "Generic type nesting is too deep ({{depth}} levels). Maximum allowed is {{maxDepth}} levels. Consider breaking down complex types into simpler ones.",
+      tooDeepNestingVietnamese: "Kiểu generic lồng quá sâu ({{depth}} cấp). Tối đa cho phép là {{maxDepth}} cấp. Hãy chia nhỏ kiểu phức tạp thành các kiểu đơn giản hơn."
+    },
+  },
+
+  create(context) {
+    const options = context.options[0] || {};
+    const maxDepth = options.maxDepth || 3;
+    const allowUtilityTypes = options.allowUtilityTypes !== false;
+    const exemptedTypeNames = new Set(options.exemptedTypeNames || []);
+
+    // Common TypeScript utility types that might need deeper nesting
+    const utilityTypes = new Set([
+      'Partial', 'Required', 'Readonly', 'Pick', 'Omit', 'Exclude', 'Extract',
+      'NonNullable', 'Parameters', 'ConstructorParameters', 'ReturnType',
+      'InstanceType', 'ThisParameterType', 'OmitThisParameter', 'ThisType',
+      'Uppercase', 'Lowercase', 'Capitalize', 'Uncapitalize'
+      // Note: Removed Promise, Array, Record, Map, Set to properly catch deep nesting
+    ]);
+
+    /**
+     * Calculate the depth of nested generics in a type node
+     * @param {Object} node - The TypeScript AST node
+     * @param {number} currentDepth - Current depth level
+     * @returns {number} The maximum depth found
+     */
+    function calculateGenericDepth(node, currentDepth = 0) {
+      if (!node) return currentDepth;
+
+      let maxDepth = currentDepth;
+
+      switch (node.type) {
+        case 'TSTypeReference':
+          // Check typeArguments (not typeParameters) for type references
+          if (node.typeArguments && node.typeArguments.params) {
+            const newDepth = currentDepth + 1;
+            for (const param of node.typeArguments.params) {
+              const paramDepth = calculateGenericDepth(param, newDepth);
+              maxDepth = Math.max(maxDepth, paramDepth);
+            }
+          }
+          break;
+
+        case 'TSUnionType':
+        case 'TSIntersectionType':
+          if (node.types) {
+            for (const type of node.types) {
+              const typeDepth = calculateGenericDepth(type, currentDepth);
+              maxDepth = Math.max(maxDepth, typeDepth);
+            }
+          }
+          break;
+
+        case 'TSTupleType':
+          if (node.elementTypes) {
+            for (const element of node.elementTypes) {
+              const elementDepth = calculateGenericDepth(element, currentDepth);
+              maxDepth = Math.max(maxDepth, elementDepth);
+            }
+          }
+          break;
+
+        case 'TSArrayType':
+          if (node.elementType) {
+            maxDepth = Math.max(maxDepth, calculateGenericDepth(node.elementType, currentDepth));
+          }
+          break;
+
+        case 'TSMappedType':
+          if (node.typeParameter) {
+            maxDepth = Math.max(maxDepth, calculateGenericDepth(node.typeParameter, currentDepth));
+          }
+          if (node.typeAnnotation) {
+            maxDepth = Math.max(maxDepth, calculateGenericDepth(node.typeAnnotation, currentDepth));
+          }
+          break;
+
+        case 'TSConditionalType':
+          if (node.checkType) {
+            maxDepth = Math.max(maxDepth, calculateGenericDepth(node.checkType, currentDepth));
+          }
+          if (node.extendsType) {
+            maxDepth = Math.max(maxDepth, calculateGenericDepth(node.extendsType, currentDepth));
+          }
+          if (node.trueType) {
+            maxDepth = Math.max(maxDepth, calculateGenericDepth(node.trueType, currentDepth));
+          }
+          if (node.falseType) {
+            maxDepth = Math.max(maxDepth, calculateGenericDepth(node.falseType, currentDepth));
+          }
+          break;
+
+        case 'TSIndexedAccessType':
+          if (node.objectType) {
+            maxDepth = Math.max(maxDepth, calculateGenericDepth(node.objectType, currentDepth));
+          }
+          if (node.indexType) {
+            maxDepth = Math.max(maxDepth, calculateGenericDepth(node.indexType, currentDepth));
+          }
+          break;
+
+        case 'TSTypeQuery':
+          if (node.exprName) {
+            maxDepth = Math.max(maxDepth, calculateGenericDepth(node.exprName, currentDepth));
+          }
+          break;
+
+        case 'TSFunctionType':
+        case 'TSConstructorType':
+          if (node.typeParameters && node.typeParameters.params) {
+            for (const param of node.typeParameters.params) {
+              const paramDepth = calculateGenericDepth(param, currentDepth + 1);
+              maxDepth = Math.max(maxDepth, paramDepth);
+            }
+          }
+          if (node.parameters) {
+            for (const param of node.parameters) {
+              if (param.typeAnnotation) {
+                const paramDepth = calculateGenericDepth(param.typeAnnotation.typeAnnotation, currentDepth);
+                maxDepth = Math.max(maxDepth, paramDepth);
+              }
+            }
+          }
+          if (node.typeAnnotation) {
+            maxDepth = Math.max(maxDepth, calculateGenericDepth(node.typeAnnotation.typeAnnotation, currentDepth));
+          }
+          break;
+      }
+
+      return maxDepth;
+    }
+
+    /**
+     * Check if a type reference is a utility type that should be exempted
+     * @param {Object} node - The TypeScript type reference node
+     * @returns {boolean} Whether this is an exempted utility type
+     */
+    function isExemptedType(node) {
+      if (node.type !== 'TSTypeReference' || !node.typeName) {
+        return false;
+      }
+
+      let typeName = '';
+      if (node.typeName.type === 'Identifier') {
+        typeName = node.typeName.name;
+      } else if (node.typeName.type === 'TSQualifiedName') {
+        // Handle qualified names like React.Component
+        typeName = getQualifiedTypeName(node.typeName);
+      }
+
+      return exemptedTypeNames.has(typeName) || 
+             (allowUtilityTypes && utilityTypes.has(typeName));
+    }
+
+    /**
+     * Get the full qualified type name from a TSQualifiedName node
+     * @param {Object} node - The TSQualifiedName node
+     * @returns {string} The full qualified name
+     */
+    function getQualifiedTypeName(node) {
+      if (node.type === 'Identifier') {
+        return node.name;
+      }
+      if (node.type === 'TSQualifiedName') {
+        return `${getQualifiedTypeName(node.left)}.${node.right.name}`;
+      }
+      return '';
+    }
+
+    /**
+     * Check a type node for excessive generic nesting
+     * @param {Object} node - The TypeScript AST node to check
+     */
+    function checkTypeNode(node) {
+      if (!node) return;
+
+      // Skip utility types if allowed
+      if (isExemptedType(node)) {
+        return;
+      }
+
+      const depth = calculateGenericDepth(node);
+      
+      if (depth > maxDepth) {
+        context.report({
+          node,
+          messageId: "tooDeepNesting",
+          data: {
+            depth,
+            maxDepth
+          }
+        });
+      }
+    }
+
+    return {
+      // Check type aliases
+      TSTypeAliasDeclaration(node) {
+        if (node.typeAnnotation) {
+          checkTypeNode(node.typeAnnotation);
+        }
+      },
+
+      // Check interface declarations
+      TSInterfaceDeclaration(node) {
+        if (node.extends) {
+          for (const extend of node.extends) {
+            checkTypeNode(extend);
+          }
+        }
+        
+        if (node.body && node.body.body) {
+          for (const member of node.body.body) {
+            if (member.typeAnnotation && member.typeAnnotation.typeAnnotation) {
+              checkTypeNode(member.typeAnnotation.typeAnnotation);
+            }
+          }
+        }
+      },
+
+      // Check function declarations
+      FunctionDeclaration(node) {
+        if (node.typeParameters && node.typeParameters.params) {
+          for (const param of node.typeParameters.params) {
+            if (param.constraint) {
+              checkTypeNode(param.constraint);
+            }
+            if (param.default) {
+              checkTypeNode(param.default);
+            }
+          }
+        }
+      },
+
+      // Check function expressions and arrow functions
+      FunctionExpression(node) {
+        if (node.typeParameters && node.typeParameters.params) {
+          for (const param of node.typeParameters.params) {
+            if (param.constraint) {
+              checkTypeNode(param.constraint);
+            }
+            if (param.default) {
+              checkTypeNode(param.default);
+            }
+          }
+        }
+      },
+
+      ArrowFunctionExpression(node) {
+        if (node.typeParameters && node.typeParameters.params) {
+          for (const param of node.typeParameters.params) {
+            if (param.constraint) {
+              checkTypeNode(param.constraint);
+            }
+            if (param.default) {
+              checkTypeNode(param.default);
+            }
+          }
+        }
+      },
+
+      // Check method definitions
+      MethodDefinition(node) {
+        if (node.value && node.value.typeParameters && node.value.typeParameters.params) {
+          for (const param of node.value.typeParameters.params) {
+            if (param.constraint) {
+              checkTypeNode(param.constraint);
+            }
+            if (param.default) {
+              checkTypeNode(param.default);
+            }
+          }
+        }
+      },
+
+      // Check variable declarations with type annotations
+      VariableDeclarator(node) {
+        if (node.id && node.id.typeAnnotation && node.id.typeAnnotation.typeAnnotation) {
+          checkTypeNode(node.id.typeAnnotation.typeAnnotation);
+        }
+      },
+
+      // Check property signatures
+      TSPropertySignature(node) {
+        if (node.typeAnnotation && node.typeAnnotation.typeAnnotation) {
+          checkTypeNode(node.typeAnnotation.typeAnnotation);
+        }
+      },
+
+      // Check method signatures
+      TSMethodSignature(node) {
+        if (node.typeParameters && node.typeParameters.params) {
+          for (const param of node.typeParameters.params) {
+            if (param.constraint) {
+              checkTypeNode(param.constraint);
+            }
+            if (param.default) {
+              checkTypeNode(param.default);
+            }
+          }
+        }
+      },
+
+      // Check call signatures
+      TSCallSignatureDeclaration(node) {
+        if (node.typeParameters && node.typeParameters.params) {
+          for (const param of node.typeParameters.params) {
+            if (param.constraint) {
+              checkTypeNode(param.constraint);
+            }
+            if (param.default) {
+              checkTypeNode(param.default);
+            }
+          }
+        }
+      },
+
+      // Check construct signatures
+      TSConstructSignatureDeclaration(node) {
+        if (node.typeParameters && node.typeParameters.params) {
+          for (const param of node.typeParameters.params) {
+            if (param.constraint) {
+              checkTypeNode(param.constraint);
+            }
+            if (param.default) {
+              checkTypeNode(param.default);
+            }
+          }
+        }
+      }
+    };
+  },
+};

package/eslint-integration/eslint.config.js

@@ -0,0 +1,125 @@
+// ESLint Flat Configuration for SunLint (ESLint v9+)
+// Following Rule C005: Single responsibility - ESLint configuration
+const typescriptParser = require('@typescript-eslint/parser');
+const typescriptPlugin = require('@typescript-eslint/eslint-plugin');
+const customPlugin = require('./eslint-plugin-custom');
+
+module.exports = [
+  {
+    files: ['**/*.{js,ts,tsx,jsx}'],
+    languageOptions: {
+      parser: typescriptParser,
+      parserOptions: {
+        ecmaVersion: 2022,
+        sourceType: 'module',
+        project: './tsconfig.json'
+      },
+      globals: {
+        console: 'readonly',
+        process: 'readonly',
+        eval: 'readonly',
+        Buffer: 'readonly',
+        __dirname: 'readonly',
+        __filename: 'readonly',
+        exports: 'writable',
+        module: 'writable',
+        require: 'readonly',
+        global: 'readonly'
+      }
+    },
+    plugins: {
+      'custom': customPlugin,
+      '@typescript-eslint': typescriptPlugin
+    },
+    rules: {
+      // Rule C019: No console.error for non-critical errors
+      'no-console': ['warn', { allow: ['warn', 'log'] }],
+      
+      // Code quality rules
+      'no-unused-vars': 'warn',
+      'prefer-const': 'warn',
+      'no-var': 'error',
+      'no-undef': 'warn',
+      
+      // Rule C005: Single responsibility principle
+      'max-lines-per-function': ['warn', { max: 50 }],
+      'complexity': ['warn', { max: 10 }],
+      
+      // Rule C014: Avoid direct new instantiation patterns
+      'no-new': 'warn',
+      
+      // Security and best practices
+      'no-eval': 'error',
+      'no-implied-eval': 'error',
+      'no-new-func': 'error',
+      'eqeqeq': 'error',
+      'curly': 'error',
+      
+      // Quality rules (dynamic loading based on category)
+      'custom/c002': 'off',
+      'custom/c003': 'off',
+      'custom/c006': 'off',
+      'custom/c010': 'off',
+      'custom/c013': 'off',
+      'custom/c014': 'off',
+      'custom/c017': 'off',
+      'custom/c018': 'off',
+      'custom/c023': 'off',
+      'custom/c027': 'off',
+      'custom/c029': 'off',
+      'custom/c030': 'off',
+      'custom/c034': 'off',
+      'custom/c035': 'off',
+      'custom/c041': 'off',
+      'custom/c042': 'off',
+      'custom/c043': 'off',
+      'custom/c047': 'off',
+      'custom/c048': 'off',
+      
+      // Security rules (dynamic loading based on category)
+      'custom/typescript_s003': 'off',
+      'custom/typescript_s005': 'off',
+      'custom/typescript_s006': 'off',
+      'custom/typescript_s008': 'off',
+      'custom/typescript_s009': 'off',
+      'custom/typescript_s010': 'off',
+      'custom/typescript_s011': 'off',
+      'custom/typescript_s012': 'off',
+      'custom/typescript_s014': 'off',
+      'custom/typescript_s015': 'off',
+      'custom/typescript_s016': 'off',
+      'custom/typescript_s017': 'off',
+      'custom/typescript_s018': 'off',
+      'custom/typescript_s019': 'off',
+      'custom/typescript_s020': 'off',
+      'custom/typescript_s022': 'off',
+      'custom/typescript_s023': 'off',
+      'custom/typescript_s025': 'off',
+      'custom/typescript_s026': 'off',
+      'custom/typescript_s027': 'off',
+      'custom/typescript_s029': 'off',
+      'custom/typescript_s030': 'off',
+      'custom/typescript_s033': 'off',
+      'custom/typescript_s034': 'off',
+      'custom/typescript_s035': 'off',
+      'custom/typescript_s036': 'off',
+      'custom/typescript_s037': 'off',
+      'custom/typescript_s038': 'off',
+      'custom/typescript_s039': 'off',
+      'custom/typescript_s041': 'off',
+      'custom/typescript_s042': 'off',
+      'custom/typescript_s043': 'off',
+      'custom/typescript_s044': 'off',
+      'custom/typescript_s045': 'off',
+      'custom/typescript_s046': 'off',
+      'custom/typescript_s047': 'off',
+      'custom/typescript_s048': 'off',
+      'custom/typescript_s050': 'off',
+      'custom/typescript_s052': 'off',
+      'custom/typescript_s054': 'off',
+      'custom/typescript_s055': 'off',
+      'custom/typescript_s057': 'off',
+      'custom/typescript_s058': 'off'
+    }
+  }
+];

package/eslint-integration/eslint.config.simple.js

@@ -0,0 +1,24 @@
+// Simple ESLint Flat Configuration for Testing
+module.exports = [
+  {
+    files: ['**/*.{js,mjs,cjs}'],
+    languageOptions: {
+      ecmaVersion: 2022,
+      sourceType: 'module',
+      globals: {
+        console: 'readonly',
+        process: 'readonly',
+        eval: 'readonly'
+      }
+    },
+    rules: {
+      'no-console': ['warn', { allow: ['warn', 'log'] }],
+      'no-unused-vars': 'warn',
+      'prefer-const': 'warn',
+      'no-var': 'error',
+      'no-undef': 'warn',
+      'no-eval': 'error',
+      'eqeqeq': 'error'
+    }
+  }
+];

package/eslint-integration/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "typescript",
+  "private": true,
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@typescript-eslint/eslint-plugin": "^8.34.1",
+    "@typescript-eslint/parser": "^8.34.1",
+    "@typescript-eslint/utils": "^8.34.1",
+    "eslint": "^9.29.0",
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.28.0",
+    "eslint-plugin-sonarjs": "^3.0.2"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "lint:ts": "eslint src/ --ext .ts,.tsx"
+  },
+  "dependencies": {
+  }
+}

package/eslint-integration/sample.ts

@@ -0,0 +1,53 @@
+// Test file to verify ESLint integration
+class UserManager {
+  private users: any[] = [];
+
+  constructor() {
+    // Rule C032: API call in constructor (should be flagged)
+    this.fetchUsers();
+  }
+
+  // Rule C006: Not verb-noun naming (should be flagged)
+  data() {
+    return this.users;
+  }
+
+  // Rule C019: Using console.error for non-critical (should be flagged)
+  processUser(user: any) {
+    if (!user.name) {
+      console.error('User name is missing');
+      return;
+    }
+    this.users.push(user);
+  }
+
+  // Rule C014: Direct new instead of DI (should be flagged)
+  createValidator() {
+    return new UserValidator();
+  }
+
+  private fetchUsers() {
+    // Mock API call
+    return fetch('/api/users');
+  }
+}
+
+class UserValidator {
+  validate(user: any) {
+    return user.name && user.email;
+  }
+}
+
+// Rule C005: Function doing multiple things (should be flagged)
+function processAndValidateUser(user: any) {
+  // Validation logic
+  if (!user.name) {
+    return false;
+  }
+  
+  // Processing logic
+  user.processedAt = new Date();
+  return true;
+}
+
+export { UserManager, UserValidator, processAndValidateUser };

package/eslint-integration/test-s003.js

@@ -0,0 +1,5 @@
+// Test S003 rule patterns
+window.location.href = req.query.redirectUrl;  // Should match AssignmentExpression
+location.href = req.body.targetUrl;            // Should match AssignmentExpression  
+location.replace = req.params.url;             // Should match AssignmentExpression
+res.redirect(req.query.returnUrl);             // Should match CallExpression

package/eslint-integration/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    // Enable latest features
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}