@intlify/eslint-plugin-vue-i18n/dist/rules/valid-plural-forms.js

ESLint plugin for Vue I18n

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
const path_1 = require("path");
const index_1 = require("../utils/index");
const debug_1 = __importDefault(require("debug"));
const rule_1 = require("../utils/rule");
const compat_1 = require("../utils/compat");
const parser_1 = require("../utils/message-compiler/parser");
const utils_1 = require("../utils/message-compiler/utils");
const debug = (0, debug_1.default)('eslint-plugin-vue-i18n:valid-plural-forms');
function create(context) {
    const filename = (0, compat_1.getFilename)(context);
    const sourceCode = (0, compat_1.getSourceCode)(context);
    const options = context.options[0] || {};
    const pluralFormCounts = options.pluralFormCounts || {};
    function getLocale() {
        var _a;
        const localeMessages = (0, index_1.getLocaleMessages)(context, {
            ignoreMissingSettingsError: true
        });
        return ((_a = localeMessages.findExistLocaleMessage(filename)) === null || _a === void 0 ? void 0 : _a.locales[0]) || null;
    }
    function verifyPluralForms(message, node) {
        if (typeof message !== 'string') {
            return;
        }
        const { ast } = (0, parser_1.parse)(message);
        if (ast.body.type !== utils_1.NodeTypes.Plural) {
            return;
        }
        const locale = getLocale();
        if (!locale) {
            return;
        }
        const allowedCounts = pluralFormCounts[locale] || [2, 3];
        const formCount = ast.body.cases.length;
        if (!allowedCounts.includes(formCount)) {
            context.report({
                loc: node.loc,
                message: `Expected ${allowedCounts.join(' or ')} plural forms for locale '${locale}', but found ${formCount}`
            });
        }
    }
    function verifyJSONLiteral(node) {
        const parent = node.parent;
        if (parent.type === 'JSONProperty' && parent.key === node) {
            return;
        }
        verifyPluralForms(node.value, node);
    }
    function verifyYAMLScalar(node) {
        const parent = node.parent;
        if (parent.type === 'YAMLPair' && parent.key === node) {
            return;
        }
        verifyPluralForms(node.value, node);
    }
    if ((0, path_1.extname)(filename) === '.vue') {
        return (0, index_1.defineCustomBlocksVisitor)(context, () => ({ JSONLiteral: verifyJSONLiteral }), () => ({ YAMLScalar: verifyYAMLScalar }));
    }
    else if (sourceCode.parserServices.isJSON) {
        if (!(0, index_1.getLocaleMessages)(context).findExistLocaleMessage(filename)) {
            return {};
        }
        return { JSONLiteral: verifyJSONLiteral };
    }
    else if (sourceCode.parserServices.isYAML) {
        if (!(0, index_1.getLocaleMessages)(context).findExistLocaleMessage(filename)) {
            return {};
        }
        return { YAMLScalar: verifyYAMLScalar };
    }
    else {
        debug(`ignore ${filename} in valid-plural-forms`);
        return {};
    }
}
module.exports = (0, rule_1.createRule)({
    meta: {
        type: 'problem',
        docs: {
            description: 'enforce valid plural form counts for each locale to prevent runtime errors',
            category: 'Best Practices',
            url: 'https://eslint-plugin-vue-i18n.intlify.dev/rules/valid-plural-forms.html',
            recommended: false
        },
        fixable: null,
        schema: [
            {
                type: 'object',
                properties: {
                    pluralFormCounts: {
                        type: 'object',
                        additionalProperties: {
                            type: 'array',
                            items: { type: 'integer', minimum: 1 },
                            minItems: 1
                        }
                    }
                },
                additionalProperties: false
            }
        ]
    },
    create
});