eslint-plugin-mocha/rules/mocha-config-value-rule.js

Eslint rules for mocha.

import { createMochaVisitors } from "../ast/mocha-visitors.js";
import { isCallExpression } from "../ast/node-types.js";
import { getStaticNumericConfigValue, visitMochaContextConfigCalls } from "../mocha/config-call.js";
import { getRuleOption } from "../rule-options.js";
import { disallowModeOptionSchema, maximumNumericMochaConfigOptionSchema, rangeNumericMochaConfigOptionSchema } from "./numeric-mocha-config-option-schemas.js";
const numericMochaConfigLimitOptionSchema = {
    oneOf: [
        disallowModeOptionSchema,
        maximumNumericMochaConfigOptionSchema,
        rangeNumericMochaConfigOptionSchema
    ]
};
const defaultNumericMochaConfigLimitOption = { mode: 'disallow' };
function reportMochaConfigCall(context, node, messageId, data) {
    context.report({
        data,
        messageId,
        node
    });
}
function validateNumericMochaConfigLimitOption(option) {
    if (option.mode !== 'range') {
        return;
    }
    if (option.min > option.max) {
        throw new TypeError('`min` must be less than or equal to `max`.');
    }
}
function reportConfiguredValue(configuredValueContext) {
    const { context, messageIds, node, option, value } = configuredValueContext;
    if (option.mode === 'max') {
        if (value > option.max) {
            reportMochaConfigCall(context, node, messageIds.aboveMax, {
                max: String(option.max),
                value: String(value)
            });
        }
        return;
    }
    if (value < option.min || value > option.max) {
        reportMochaConfigCall(context, node, messageIds.outsideRange, {
            max: String(option.max),
            min: String(option.min),
            value: String(value)
        });
    }
}
function readConfiguredValue(context, node) {
    return getStaticNumericConfigValue(node, context.sourceCode) ?? undefined;
}
export function createSimpleNumericMochaConfigLimitRule(ruleDefinition) {
    return {
        meta: {
            type: 'suggestion',
            languages: ['js/js'],
            docs: {
                description: ruleDefinition.description,
                recommended: false,
                url: `https://github.com/lo1tuma/eslint-plugin-mocha/blob/main/documentation/rules/${ruleDefinition.name}.md`
            },
            defaultOptions: [defaultNumericMochaConfigLimitOption],
            messages: ruleDefinition.messages,
            schema: [numericMochaConfigLimitOptionSchema]
        },
        create(context) {
            const option = getRuleOption(context);
            validateNumericMochaConfigLimitOption(option);
            function checkConfigCall(node) {
                if (option.mode === 'disallow') {
                    reportMochaConfigCall(context, node, ruleDefinition.messageIds.disallow);
                    return;
                }
                const value = readConfiguredValue(context, node);
                if (value === undefined) {
                    return;
                }
                reportConfiguredValue({
                    context,
                    node,
                    messageIds: ruleDefinition.messageIds,
                    option,
                    value
                });
            }
            return createMochaVisitors(context, {
                config(visitorContext) {
                    const { node } = visitorContext;
                    if (visitorContext.config === ruleDefinition.configName && isCallExpression(node)) {
                        checkConfigCall(node);
                    }
                },
                anyTestEntityCallback(visitorContext) {
                    visitMochaContextConfigCalls(context.sourceCode, visitorContext.node.body, ruleDefinition.configName, checkConfigCall);
                }
            });
        }
    };
}
//# sourceMappingURL=mocha-config-value-rule.js.map