auto-cr-cmd/dist/config/autocrrc.js

Fast automated code review CLI powered by SWC-based static analysis

"use strict";
var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.loadAutoCrRc = loadAutoCrRc;
exports.applyRuleConfig = applyRuleConfig;
var fs_1 = __importDefault(require("fs"));
var path_1 = __importDefault(require("path"));
var auto_cr_rules_1 = require("auto-cr-rules");
var i18n_1 = require("../i18n");
var RC_CANDIDATES = ['.autocrrc.json', '.autocrrc.js'];
function loadAutoCrRc(configPath) {
    var warnings = [];
    var t = (0, i18n_1.getTranslator)();
    var resolvedPath = resolveConfigPath(configPath);
    if (!resolvedPath) {
        return { warnings: warnings };
    }
    if (!fs_1.default.existsSync(resolvedPath)) {
        warnings.push(t.autocrrcPathMissing({ path: resolvedPath }));
        return { warnings: warnings };
    }
    try {
        var raw = readConfigFile(resolvedPath);
        var config = unwrapDefault(raw);
        if (!isRecord(config)) {
            warnings.push(t.autocrrcInvalidFormat({ path: resolvedPath }));
            return { warnings: warnings };
        }
        if (config.rules !== undefined && !isRecord(config.rules)) {
            warnings.push(t.autocrrcInvalidRulesField({ path: resolvedPath }));
            return { warnings: warnings };
        }
        return {
            path: resolvedPath,
            rules: config.rules,
            warnings: warnings,
        };
    }
    catch (error) {
        var detail = error instanceof Error ? error.message : String(error);
        warnings.push(t.autocrrcLoadFailed({ path: resolvedPath, error: detail }));
        return { warnings: warnings };
    }
}
function applyRuleConfig(rules, ruleSettings, onWarning) {
    if (!ruleSettings || Object.keys(ruleSettings).length === 0) {
        return rules;
    }
    var t = (0, i18n_1.getTranslator)();
    var configured = [];
    for (var _i = 0, rules_1 = rules; _i < rules_1.length; _i++) {
        var rule = rules_1[_i];
        var hasSetting = Object.prototype.hasOwnProperty.call(ruleSettings, rule.name);
        if (!hasSetting) {
            configured.push(rule);
            continue;
        }
        var rawSetting = ruleSettings[rule.name];
        var normalized = normalizeRuleSetting(rawSetting);
        if (normalized === 'off') {
            continue;
        }
        if (normalized === null) {
            onWarning(t.autocrrcInvalidRuleSetting({ ruleName: rule.name, value: stringifyValue(rawSetting) }));
            configured.push(rule);
            continue;
        }
        if (normalized === undefined) {
            configured.push(rule);
            continue;
        }
        configured.push(__assign(__assign({}, rule), { severity: normalized }));
    }
    return configured;
}
function resolveConfigPath(explicitPath) {
    if (explicitPath) {
        return path_1.default.isAbsolute(explicitPath) ? explicitPath : path_1.default.resolve(process.cwd(), explicitPath);
    }
    for (var _i = 0, RC_CANDIDATES_1 = RC_CANDIDATES; _i < RC_CANDIDATES_1.length; _i++) {
        var candidate = RC_CANDIDATES_1[_i];
        var resolved = path_1.default.resolve(process.cwd(), candidate);
        if (fs_1.default.existsSync(resolved)) {
            return resolved;
        }
    }
    return null;
}
function readConfigFile(filePath) {
    if (filePath.endsWith('.json')) {
        var raw = fs_1.default.readFileSync(filePath, 'utf-8');
        return JSON.parse(raw);
    }
    if (filePath.endsWith('.js')) {
        // eslint-disable-next-line @typescript-eslint/no-require-imports
        return require(filePath);
    }
    return {};
}
function unwrapDefault(value) {
    var _a;
    if (isRecord(value) && 'default' in value) {
        return (_a = value.default) !== null && _a !== void 0 ? _a : value;
    }
    return value;
}
function isRecord(value) {
    return typeof value === 'object' && value !== null && !Array.isArray(value);
}
function normalizeRuleSetting(input) {
    if (input === undefined) {
        return undefined;
    }
    if (input === null) {
        return null;
    }
    if (typeof input === 'boolean') {
        return input ? undefined : 'off';
    }
    if (typeof input === 'number') {
        if (input === 0)
            return 'off';
        if (input === 1)
            return auto_cr_rules_1.RuleSeverity.Warning;
        if (input === 2)
            return auto_cr_rules_1.RuleSeverity.Error;
        return null;
    }
    if (typeof input === 'string') {
        var normalized = input.toLowerCase();
        if (normalized === 'off' || normalized === 'disable' || normalized === 'disabled') {
            return 'off';
        }
        if (normalized === 'warn' || normalized === 'warning') {
            return auto_cr_rules_1.RuleSeverity.Warning;
        }
        if (normalized === 'error') {
            return auto_cr_rules_1.RuleSeverity.Error;
        }
        if (normalized === 'optimizing' || normalized === 'optimize' || normalized === 'optimise') {
            return auto_cr_rules_1.RuleSeverity.Optimizing;
        }
        return null;
    }
    if (input === auto_cr_rules_1.RuleSeverity.Error || input === auto_cr_rules_1.RuleSeverity.Warning || input === auto_cr_rules_1.RuleSeverity.Optimizing) {
        return input;
    }
    return null;
}
function stringifyValue(value) {
    if (typeof value === 'string') {
        return "\"".concat(value, "\"");
    }
    try {
        return JSON.stringify(value);
    }
    catch (_a) {
        return String(value);
    }
}