lwc-linter/lib/core/rule-manager.js

A comprehensive CLI tool for linting Lightning Web Components v8.0.0+ with modern LWC patterns, decorators, lifecycle hooks, and Salesforce platform integration

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.RuleManager = void 0;
exports.listRules = listRules;
const chalk_1 = __importDefault(require("chalk"));
const code_quality_1 = require("../rules/code-quality");
const accessibility_1 = require("../rules/accessibility");
const performance_1 = require("../rules/performance");
const security_1 = require("../rules/security");
const eslint_prettier_1 = require("../rules/eslint-prettier");
class RuleManager {
    constructor(config) {
        this.rules = new Map();
        this.config = config;
        this.loadRules();
    }
    loadRules() {
        // Load all rule categories
        const allRules = [
            ...(0, code_quality_1.loadCodeQualityRules)(),
            ...(0, accessibility_1.loadAccessibilityRules)(),
            ...(0, performance_1.loadPerformanceRules)(),
            ...(0, security_1.loadSecurityRules)(),
            ...(0, eslint_prettier_1.loadESLintPrettierRules)()
        ];
        // Register rules
        allRules.forEach(rule => {
            this.rules.set(rule.name, rule);
        });
    }
    getRule(ruleName) {
        return this.rules.get(ruleName);
    }
    getAllRules() {
        return Array.from(this.rules.values());
    }
    isRuleEnabled(ruleName) {
        const ruleConfig = this.config.rules[ruleName];
        if (ruleConfig === undefined) {
            // Use default rule severity if not configured
            const rule = this.rules.get(ruleName);
            return rule ? rule.severity !== 'info' : false;
        }
        if (Array.isArray(ruleConfig)) {
            return ruleConfig[0] !== 'off';
        }
        return ruleConfig !== 'off';
    }
    checkJavaScriptRules(content, filePath, ast) {
        const issues = [];
        this.rules.forEach((rule, ruleName) => {
            if (this.isRuleEnabled(ruleName) &&
                (rule.category === 'code-quality' || rule.category === 'performance' || rule.category === 'security')) {
                try {
                    const ruleIssues = rule.check(content, filePath, this.config);
                    issues.push(...ruleIssues);
                }
                catch (error) {
                    console.warn(chalk_1.default.yellow(`Warning: Rule ${ruleName} failed: ${error}`));
                }
            }
        });
        return issues;
    }
    checkHTMLRules(content, filePath, document) {
        const issues = [];
        this.rules.forEach((rule, ruleName) => {
            if (this.isRuleEnabled(ruleName) &&
                (rule.category === 'code-quality' || rule.category === 'performance')) {
                try {
                    const ruleIssues = rule.check(content, filePath, this.config);
                    issues.push(...ruleIssues);
                }
                catch (error) {
                    console.warn(chalk_1.default.yellow(`Warning: Rule ${ruleName} failed: ${error}`));
                }
            }
        });
        return issues;
    }
    checkCSSRules(content, filePath, ast) {
        const issues = [];
        this.rules.forEach((rule, ruleName) => {
            if (this.isRuleEnabled(ruleName) &&
                (rule.category === 'code-quality' || rule.category === 'performance')) {
                try {
                    const ruleIssues = rule.check(content, filePath, this.config);
                    issues.push(...ruleIssues);
                }
                catch (error) {
                    console.warn(chalk_1.default.yellow(`Warning: Rule ${ruleName} failed: ${error}`));
                }
            }
        });
        return issues;
    }
    checkAccessibilityRules(content, filePath, document) {
        const issues = [];
        this.rules.forEach((rule, ruleName) => {
            if (this.isRuleEnabled(ruleName) && rule.category === 'accessibility') {
                try {
                    const ruleIssues = rule.check(content, filePath, this.config);
                    issues.push(...ruleIssues);
                }
                catch (error) {
                    console.warn(chalk_1.default.yellow(`Warning: Rule ${ruleName} failed: ${error}`));
                }
            }
        });
        return issues;
    }
}
exports.RuleManager = RuleManager;
function listRules() {
    const ruleManager = new RuleManager({
        rules: {},
        accessibility: { enabled: true, level: 'AA' },
        performance: { enabled: true },
        security: { enabled: true },
        eslintIntegration: { enabled: true },
        prettierIntegration: { enabled: true }
    });
    const allRules = ruleManager.getAllRules();
    const categories = ['code-quality', 'accessibility', 'performance', 'security'];
    console.log(chalk_1.default.blue('\n📋 Available LWC Linter Rules:\n'));
    categories.forEach(category => {
        const categoryRules = allRules.filter(rule => rule.category === category);
        if (categoryRules.length > 0) {
            console.log(chalk_1.default.bold(`\n${category.toUpperCase().replace('-', ' ')}:`));
            categoryRules.forEach(rule => {
                const severityColor = rule.severity === 'error' ? 'red' :
                    rule.severity === 'warn' ? 'yellow' : 'gray';
                const fixableText = rule.fixable ? chalk_1.default.green(' [fixable]') : '';
                console.log(`  ${chalk_1.default[severityColor]('●')} ${chalk_1.default.bold(rule.name)} - ${rule.description}${fixableText}`);
            });
        }
    });
    console.log(chalk_1.default.gray('\nUse --disable <rule1,rule2> to disable specific rules'));
    console.log(chalk_1.default.gray('Use -c <config-file> to specify custom rule configuration\n'));
}
//# sourceMappingURL=rule-manager.js.map