eslint-plugin-formatjs 5.4.1 → 6.0.0

package/lib_esnext/rules/enforce-plural-rules.js

@@ -1,103 +0,0 @@
-import { isPluralElement, parse, } from '@formatjs/icu-messageformat-parser';
-import { getParserServices } from '../context-compat';
-import { extractMessages, getSettings } from '../util';
-var LDML;
-(function (LDML) {
-    LDML["zero"] = "zero";
-    LDML["one"] = "one";
-    LDML["two"] = "two";
-    LDML["few"] = "few";
-    LDML["many"] = "many";
-    LDML["other"] = "other";
-})(LDML || (LDML = {}));
-function verifyAst(plConfig, ast) {
-    const errors = [];
-    for (const el of ast) {
-        if (isPluralElement(el)) {
-            const rules = Object.keys(plConfig);
-            for (const rule of rules) {
-                if (plConfig[rule] && !el.options[rule]) {
-                    errors.push({ messageId: 'missingPlural', data: { rule } });
-                }
-                if (!plConfig[rule] && el.options[rule]) {
-                    errors.push({ messageId: 'forbidden', data: { rule } });
-                }
-            }
-            const { options } = el;
-            for (const selector of Object.keys(options)) {
-                errors.push(...verifyAst(plConfig, options[selector].value));
-            }
-        }
-    }
-    return errors;
-}
-function checkNode(context, node) {
-    const settings = getSettings(context);
-    const msgs = extractMessages(node, settings);
-    if (!msgs.length) {
-        return;
-    }
-    const plConfig = context.options[0];
-    if (!plConfig) {
-        return;
-    }
-    for (const [{ message: { defaultMessage }, messageNode, },] of msgs) {
-        if (!defaultMessage || !messageNode) {
-            continue;
-        }
-        const errors = verifyAst(plConfig, parse(defaultMessage, {
-            ignoreTag: settings.ignoreTag,
-        }));
-        for (const error of errors) {
-            context.report({
-                node: messageNode,
-                ...error,
-            });
-        }
-    }
-}
-export const name = 'enforce-plural-rules';
-export const rule = {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Enforce plural rules to always specify certain categories like `one`/`other`',
-            url: 'https://formatjs.github.io/docs/tooling/linter#enforce-plural-rules',
-        },
-        fixable: 'code',
-        schema: [
-            {
-                type: 'object',
-                properties: Object.keys(LDML).reduce((schema, k) => {
-                    schema[k] = {
-                        type: 'boolean',
-                    };
-                    return schema;
-                }, {}),
-                additionalProperties: false,
-            },
-        ],
-        messages: {
-            missingPlural: `Missing plural rule "{{rule}}"`,
-            forbidden: `Plural rule "{{rule}}" is forbidden`,
-        },
-    },
-    defaultOptions: [],
-    create(context) {
-        const callExpressionVisitor = (node) => checkNode(context, node);
-        const parserServices = getParserServices(context);
-        //@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
-        if (parserServices?.defineTemplateBodyVisitor) {
-            //@ts-expect-error
-            return parserServices.defineTemplateBodyVisitor({
-                CallExpression: callExpressionVisitor,
-            }, {
-                CallExpression: callExpressionVisitor,
-            });
-        }
-        return {
-            JSXOpeningElement: (node) => checkNode(context, node),
-            CallExpression: callExpressionVisitor,
-        };
-    },
-};

package/lib_esnext/rules/no-camel-case.d.ts

@@ -1,5 +0,0 @@
-import { RuleModule } from '@typescript-eslint/utils/ts-eslint';
-type MessageIds = 'camelcase';
-export declare const name = "no-camel-case";
-export declare const rule: RuleModule<MessageIds>;
-export {};

package/lib_esnext/rules/no-camel-case.js

@@ -1,76 +0,0 @@
-import { isArgumentElement, isPluralElement, parse, } from '@formatjs/icu-messageformat-parser';
-import { getParserServices } from '../context-compat';
-import { extractMessages, getSettings } from '../util';
-export const name = 'no-camel-case';
-const CAMEL_CASE_REGEX = /[A-Z]/;
-function verifyAst(ast) {
-    const errors = [];
-    for (const el of ast) {
-        if (isArgumentElement(el)) {
-            if (CAMEL_CASE_REGEX.test(el.value)) {
-                errors.push({ messageId: 'camelcase', data: {} });
-            }
-            continue;
-        }
-        if (isPluralElement(el)) {
-            if (CAMEL_CASE_REGEX.test(el.value)) {
-                errors.push({ messageId: 'camelcase', data: {} });
-            }
-            const { options } = el;
-            for (const selector of Object.keys(options)) {
-                errors.push(...verifyAst(options[selector].value));
-            }
-        }
-    }
-    return errors;
-}
-function checkNode(context, node) {
-    const settings = getSettings(context);
-    const msgs = extractMessages(node, settings);
-    for (const [{ message: { defaultMessage }, messageNode, },] of msgs) {
-        if (!defaultMessage || !messageNode) {
-            continue;
-        }
-        const errors = verifyAst(parse(defaultMessage, {
-            ignoreTag: settings.ignoreTag,
-        }));
-        for (const error of errors) {
-            context.report({
-                node: messageNode,
-                ...error,
-            });
-        }
-    }
-}
-export const rule = {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Disallow camel case placeholders in message',
-            url: 'https://formatjs.github.io/docs/tooling/linter#no-camel-case',
-        },
-        fixable: 'code',
-        schema: [],
-        messages: {
-            camelcase: 'Camel case arguments are not allowed',
-        },
-    },
-    defaultOptions: [],
-    create(context) {
-        const callExpressionVisitor = (node) => checkNode(context, node);
-        const parserServices = getParserServices(context);
-        //@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
-        if (parserServices?.defineTemplateBodyVisitor) {
-            //@ts-expect-error
-            return parserServices.defineTemplateBodyVisitor({
-                CallExpression: callExpressionVisitor,
-            }, {
-                CallExpression: callExpressionVisitor,
-            });
-        }
-        return {
-            JSXOpeningElement: (node) => checkNode(context, node),
-            CallExpression: callExpressionVisitor,
-        };
-    },
-};

package/lib_esnext/rules/no-complex-selectors.d.ts

@@ -1,9 +0,0 @@
-import { RuleModule } from '@typescript-eslint/utils/ts-eslint';
-interface Config {
-    limit: number;
-}
-type MessageIds = 'tooComplex' | 'parserError';
-type Options = [Config?];
-export declare const name = "no-complex-selectors";
-export declare const rule: RuleModule<MessageIds, Options>;
-export {};

package/lib_esnext/rules/no-complex-selectors.js

@@ -1,136 +0,0 @@
-import { TYPE, parse, } from '@formatjs/icu-messageformat-parser';
-import { getParserServices } from '../context-compat';
-import { extractMessages, getSettings } from '../util';
-function calculateComplexity(ast) {
-    // Dynamic programming: define a complexity function f, where:
-    //   f(plural | select) = sum(f(option) for each option) * f(next element),
-    //   f(tag) = f(first element of children) * f(next element),
-    //   f(other) = f(next element),
-    //   f(out of bound) = 1.
-    const complexityByNode = new Map();
-    return _calculate(ast, 0);
-    function _calculate(ast, index) {
-        const element = ast[index];
-        if (!element) {
-            return 1;
-        }
-        const cachedComplexity = complexityByNode.get(element);
-        if (cachedComplexity !== undefined) {
-            return cachedComplexity;
-        }
-        let complexity;
-        switch (element.type) {
-            case TYPE.plural:
-            case TYPE.select: {
-                let sumOfOptions = 0;
-                for (const { value } of Object.values(element.options)) {
-                    sumOfOptions += _calculate(value, 0);
-                }
-                complexity = sumOfOptions * _calculate(ast, index + 1);
-                break;
-            }
-            case TYPE.tag:
-                complexity =
-                    _calculate(element.children, 0) * _calculate(ast, index + 1);
-                break;
-            default:
-                complexity = _calculate(ast, index + 1);
-                break;
-        }
-        complexityByNode.set(element, complexity);
-        return complexity;
-    }
-}
-function checkNode(context, node) {
-    const settings = getSettings(context);
-    const msgs = extractMessages(node, settings);
-    if (!msgs.length) {
-        return;
-    }
-    const config = {
-        limit: 20,
-        ...(context.options[0] || {}),
-    };
-    for (const [{ message: { defaultMessage }, messageNode, },] of msgs) {
-        if (!defaultMessage || !messageNode) {
-            continue;
-        }
-        let ast;
-        try {
-            ast = parse(defaultMessage, {
-                ignoreTag: settings.ignoreTag,
-            });
-        }
-        catch (e) {
-            context.report({
-                node: messageNode,
-                messageId: 'parserError',
-                data: { message: e instanceof Error ? e.message : String(e) },
-            });
-            return;
-        }
-        const complexity = calculateComplexity(ast);
-        if (complexity > config.limit) {
-            context.report({
-                node: messageNode,
-                messageId: 'tooComplex',
-                data: {
-                    complexity,
-                    limit: config.limit,
-                },
-            });
-        }
-    }
-}
-export const name = 'no-complex-selectors';
-export const rule = {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: `Make sure a sentence is not too complex.
-Complexity is determined by how many strings are produced when we try to
-flatten the sentence given its selectors. For example:
-"I have {count, plural, one{a dog} other{many dogs}}"
-has the complexity of 2 because flattening the plural selector
-results in 2 sentences: "I have a dog" & "I have many dogs".
-Default complexity limit is 20
-(using Smartling as a reference: https://help.smartling.com/hc/en-us/articles/360008030994-ICU-MessageFormat)
-`,
-            url: 'https://formatjs.github.io/docs/tooling/linter#no-complex-selectors',
-        },
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    limit: {
-                        type: 'number',
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-        fixable: 'code',
-        messages: {
-            tooComplex: `Message complexity is too high ({{complexity}} vs limit at {{limit}})`,
-            parserError: '{{message}}',
-        },
-    },
-    defaultOptions: [{ limit: 20 }],
-    create(context) {
-        const callExpressionVisitor = (node) => checkNode(context, node);
-        const parserServices = getParserServices(context);
-        //@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
-        if (parserServices?.defineTemplateBodyVisitor) {
-            //@ts-expect-error
-            return parserServices.defineTemplateBodyVisitor({
-                CallExpression: callExpressionVisitor,
-            }, {
-                CallExpression: callExpressionVisitor,
-            });
-        }
-        return {
-            JSXOpeningElement: (node) => checkNode(context, node),
-            CallExpression: callExpressionVisitor,
-        };
-    },
-};

package/lib_esnext/rules/no-emoji.d.ts

@@ -1,9 +0,0 @@
-import { RuleModule } from '@typescript-eslint/utils/ts-eslint';
-export declare const name = "no-emoji";
-type MessageIds = 'notAllowed' | 'notAllowedAboveVersion';
-type NoEmojiConfig = {
-    versionAbove: string;
-};
-export type Options = [NoEmojiConfig?];
-export declare const rule: RuleModule<MessageIds, Options>;
-export {};

package/lib_esnext/rules/no-emoji.js

@@ -1,99 +0,0 @@
-import { extractEmojis, filterEmojis, getAllEmojis, hasEmoji, isValidEmojiVersion, } from 'unicode-emoji-utils';
-import { getParserServices } from '../context-compat';
-import { extractMessages, getSettings } from '../util';
-export const name = 'no-emoji';
-function checkNode(context, node) {
-    const msgs = extractMessages(node, getSettings(context));
-    let allowedEmojis = [];
-    let versionAbove;
-    const [emojiConfig] = context.options;
-    if (emojiConfig?.versionAbove &&
-        isValidEmojiVersion(emojiConfig.versionAbove) &&
-        !versionAbove &&
-        allowedEmojis.length === 0) {
-        versionAbove = emojiConfig.versionAbove;
-        allowedEmojis = getAllEmojis(filterEmojis(versionAbove));
-    }
-    for (const [{ message: { defaultMessage }, messageNode, },] of msgs) {
-        if (!defaultMessage || !messageNode) {
-            continue;
-        }
-        if (hasEmoji(defaultMessage)) {
-            if (versionAbove) {
-                for (const emoji of extractEmojis(defaultMessage)) {
-                    if (!allowedEmojis.includes(emoji)) {
-                        context.report({
-                            node: messageNode,
-                            messageId: 'notAllowedAboveVersion',
-                            data: {
-                                versionAbove,
-                                emoji,
-                            },
-                        });
-                    }
-                }
-            }
-            else {
-                context.report({
-                    node: messageNode,
-                    messageId: 'notAllowed',
-                });
-            }
-        }
-    }
-}
-const versionAboveEnums = [
-    '0.6',
-    '0.7',
-    '1.0',
-    '2.0',
-    '3.0',
-    '4.0',
-    '5.0',
-    '11.0',
-    '12.0',
-    '12.1',
-    '13.0',
-    '13.1',
-    '14.0',
-    '15.0',
-];
-export const rule = {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Disallow emojis in message',
-            url: 'https://formatjs.github.io/docs/tooling/linter#no-emoji',
-        },
-        fixable: 'code',
-        schema: [
-            {
-                type: 'object',
-                properties: { versionAbove: { type: 'string', enum: versionAboveEnums } },
-                additionalProperties: false,
-            },
-        ],
-        messages: {
-            notAllowed: 'Emojis are not allowed',
-            notAllowedAboveVersion: 'Emojis above version {{versionAbove}} are not allowed - Emoji: {{emoji}}',
-        },
-    },
-    defaultOptions: [],
-    create(context) {
-        const callExpressionVisitor = (node) => checkNode(context, node);
-        const parserServices = getParserServices(context);
-        //@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
-        if (parserServices?.defineTemplateBodyVisitor) {
-            //@ts-expect-error
-            return parserServices.defineTemplateBodyVisitor({
-                CallExpression: callExpressionVisitor,
-            }, {
-                CallExpression: callExpressionVisitor,
-            });
-        }
-        return {
-            JSXOpeningElement: (node) => checkNode(context, node),
-            CallExpression: callExpressionVisitor,
-        };
-    },
-};

package/lib_esnext/rules/no-id.d.ts

@@ -1,5 +0,0 @@
-import { RuleModule } from '@typescript-eslint/utils/ts-eslint';
-type MessageIds = 'noId';
-export declare const name = "no-id";
-export declare const rule: RuleModule<MessageIds>;
-export {};

package/lib_esnext/rules/no-id.js

@@ -1,58 +0,0 @@
-import { getParserServices } from '../context-compat';
-import { extractMessages, getSettings } from '../util';
-function isComment(token) {
-    return !!token && (token.type === 'Block' || token.type === 'Line');
-}
-export const name = 'no-id';
-function checkNode(context, node) {
-    const msgs = extractMessages(node, getSettings(context));
-    for (const [{ idPropNode }] of msgs) {
-        if (idPropNode) {
-            context.report({
-                node: idPropNode,
-                messageId: 'noId',
-                fix(fixer) {
-                    const src = context.getSourceCode();
-                    const token = src.getTokenAfter(idPropNode);
-                    const fixes = [fixer.remove(idPropNode)];
-                    if (token && !isComment(token) && token?.value === ',') {
-                        fixes.push(fixer.remove(token));
-                    }
-                    return fixes;
-                },
-            });
-        }
-    }
-}
-export const rule = {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Ban explicit ID from MessageDescriptor',
-            url: 'https://formatjs.github.io/docs/tooling/linter#no-id',
-        },
-        fixable: 'code',
-        schema: [],
-        messages: {
-            noId: 'Manual `id` are not allowed in message descriptor',
-        },
-    },
-    defaultOptions: [],
-    create(context) {
-        const callExpressionVisitor = (node) => checkNode(context, node);
-        const parserServices = getParserServices(context);
-        //@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
-        if (parserServices?.defineTemplateBodyVisitor) {
-            //@ts-expect-error
-            return parserServices.defineTemplateBodyVisitor({
-                CallExpression: callExpressionVisitor,
-            }, {
-                CallExpression: callExpressionVisitor,
-            });
-        }
-        return {
-            JSXOpeningElement: (node) => checkNode(context, node),
-            CallExpression: callExpressionVisitor,
-        };
-    },
-};

package/lib_esnext/rules/no-invalid-icu.d.ts

@@ -1,5 +0,0 @@
-import { RuleModule } from '@typescript-eslint/utils/ts-eslint';
-type MessageIds = 'icuError';
-export declare const name = "no-invalid-icu";
-export declare const rule: RuleModule<MessageIds>;
-export {};

package/lib_esnext/rules/no-invalid-icu.js

@@ -1,60 +0,0 @@
-import { parse } from '@formatjs/icu-messageformat-parser';
-import { getParserServices } from '../context-compat';
-import { extractMessages, getSettings } from '../util';
-export const name = 'no-invalid-icu';
-function checkNode(context, node) {
-    const settings = getSettings(context);
-    const msgs = extractMessages(node, settings);
-    if (!msgs.length) {
-        return;
-    }
-    for (const [{ message: { defaultMessage }, messageNode, },] of msgs) {
-        if (!defaultMessage || !messageNode) {
-            continue;
-        }
-        try {
-            parse(defaultMessage, {
-                ignoreTag: settings.ignoreTag,
-            });
-        }
-        catch (e) {
-            const msg = e instanceof Error ? e.message : e;
-            context.report({
-                node: messageNode,
-                messageId: 'icuError',
-                data: { message: `Error parsing ICU string: ${msg}` },
-            });
-        }
-    }
-}
-export const rule = {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: `Make sure ICU messages are formatted correctly with no bad select statements, plurals, etc.`,
-        },
-        fixable: 'code',
-        schema: [],
-        messages: {
-            icuError: 'Invalid ICU Message format: {{message}}',
-        },
-    },
-    defaultOptions: [],
-    create(context) {
-        const callExpressionVisitor = (node) => checkNode(context, node);
-        const parserServices = getParserServices(context);
-        //@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
-        if (parserServices?.defineTemplateBodyVisitor) {
-            //@ts-expect-error
-            return parserServices.defineTemplateBodyVisitor({
-                CallExpression: callExpressionVisitor,
-            }, {
-                CallExpression: callExpressionVisitor,
-            });
-        }
-        return {
-            JSXOpeningElement: (node) => checkNode(context, node),
-            CallExpression: callExpressionVisitor,
-        };
-    },
-};

package/lib_esnext/rules/no-literal-string-in-jsx.d.ts

@@ -1,13 +0,0 @@
-import { RuleModule } from '@typescript-eslint/utils/ts-eslint';
-type PropMatcher = readonly [TagNamePattern: string, PropNamePattern: string][];
-type Config = {
-    props?: {
-        include?: PropMatcher;
-        exclude?: PropMatcher;
-    };
-};
-type MessageIds = 'noLiteralStringInJsx';
-type Options = [Config?];
-export declare const name = "no-literal-string-in-jsx";
-export declare const rule: RuleModule<MessageIds, Options>;
-export {};