eslint-plugin-formatjs 5.4.2 → 6.0.1

package/lib_esnext/rules/no-literal-string-in-jsx.js

@@ -1,179 +0,0 @@
-import { TSESTree } from '@typescript-eslint/utils';
-import picomatch from 'picomatch';
-const propMatcherSchema = {
-    type: 'array',
-    items: {
-        type: 'array',
-        items: [{ type: 'string' }, { type: 'string' }],
-    },
-};
-const defaultPropIncludePattern = [
-    ['*', 'aria-{label,description,details,errormessage}'],
-    ['[a-z]*([a-z0-9])', '(placeholder|title)'],
-    ['img', 'alt'],
-];
-const defaultPropExcludePattern = [];
-function stringifyJsxTagName(tagName) {
-    switch (tagName.type) {
-        case TSESTree.AST_NODE_TYPES.JSXIdentifier:
-            return tagName.name;
-        case TSESTree.AST_NODE_TYPES.JSXMemberExpression:
-            return `${stringifyJsxTagName(tagName.object)}.${tagName.property.name}`;
-        case TSESTree.AST_NODE_TYPES.JSXNamespacedName:
-            return `${tagName.namespace.name}:${tagName.name.name}`;
-    }
-}
-function compilePropMatcher(propMatcher) {
-    return propMatcher.map(([tagNamePattern, propNamePattern]) => {
-        return [
-            picomatch.makeRe(tagNamePattern, { contains: false }),
-            picomatch.makeRe(propNamePattern, { contains: false }),
-        ];
-    });
-}
-export const name = 'no-literal-string-in-jsx';
-export const rule = {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Disallow untranslated literal strings without translation.',
-            url: 'https://formatjs.github.io/docs/tooling/linter#no-literal-string-in-jsx',
-        },
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    props: {
-                        type: 'object',
-                        properties: {
-                            include: {
-                                ...propMatcherSchema,
-                            },
-                            exclude: {
-                                ...propMatcherSchema,
-                            },
-                        },
-                    },
-                },
-            },
-        ],
-        messages: {
-            noLiteralStringInJsx: 'Cannot have untranslated text in JSX',
-        },
-    },
-    defaultOptions: [],
-    // TODO: Vue support
-    create(context) {
-        const userConfig = context.options[0] || {};
-        const propIncludePattern = compilePropMatcher([
-            ...defaultPropIncludePattern,
-            ...(userConfig.props?.include ?? []),
-        ]);
-        const propExcludePattern = compilePropMatcher([
-            ...defaultPropExcludePattern,
-            ...(userConfig.props?.exclude ?? []),
-        ]);
-        const lexicalJsxStack = [];
-        const shouldSkipCurrentJsxAttribute = (node) => {
-            const currentJsxNode = lexicalJsxStack[lexicalJsxStack.length - 1];
-            if (currentJsxNode.type === 'JSXFragment') {
-                return false;
-            }
-            const nameString = stringifyJsxTagName(currentJsxNode.openingElement.name);
-            const attributeName = typeof node.name.name === 'string'
-                ? node.name.name
-                : node.name.name.name;
-            // match exclude
-            for (const [tagNamePattern, propNamePattern] of propExcludePattern) {
-                if (tagNamePattern.test(nameString) &&
-                    propNamePattern.test(attributeName)) {
-                    return true;
-                }
-            }
-            // match include
-            for (const [tagNamePattern, propNamePattern] of propIncludePattern) {
-                if (tagNamePattern.test(nameString) &&
-                    propNamePattern.test(attributeName)) {
-                    return false;
-                }
-            }
-            return true;
-        };
-        const checkJSXExpression = (node) => {
-            // Check if this is either a string literal / template literal, or the concat of them.
-            // It also ignores the empty string.
-            if ((node.type === 'Literal' &&
-                typeof node.value === 'string' &&
-                node.value.length > 0) ||
-                (node.type === 'TemplateLiteral' &&
-                    (node.quasis.length > 1 || node.quasis[0].value.raw.length > 0))) {
-                context.report({
-                    node: node,
-                    messageId: 'noLiteralStringInJsx',
-                });
-            }
-            else if (node.type === 'BinaryExpression' && node.operator === '+') {
-                checkJSXExpression(node.left);
-                checkJSXExpression(node.right);
-            }
-            else if (node.type === 'ConditionalExpression') {
-                checkJSXExpression(node.consequent);
-                checkJSXExpression(node.alternate);
-            }
-            else if (node.type === 'LogicalExpression') {
-                checkJSXExpression(node.left);
-                checkJSXExpression(node.right);
-            }
-        };
-        return {
-            JSXElement: (node) => {
-                lexicalJsxStack.push(node);
-            },
-            'JSXElement:exit': () => {
-                lexicalJsxStack.pop();
-            },
-            JSXFragment: (node) => {
-                lexicalJsxStack.push(node);
-            },
-            'JSXFragment:exit': () => {
-                lexicalJsxStack.pop();
-            },
-            JSXAttribute: (node) => {
-                if (shouldSkipCurrentJsxAttribute(node)) {
-                    return;
-                }
-                if (!node.value) {
-                    return;
-                }
-                if (node.value.type === 'Literal' &&
-                    typeof node.value.value === 'string' &&
-                    node.value.value.length > 0) {
-                    context.report({
-                        node: node,
-                        messageId: 'noLiteralStringInJsx',
-                    });
-                }
-                else if (node.value.type === 'JSXExpressionContainer' &&
-                    node.value.expression.type !== 'JSXEmptyExpression') {
-                    checkJSXExpression(node.value.expression);
-                }
-            },
-            JSXText: (node) => {
-                // Ignore purely spacing fragments
-                if (!node.value.replace(/\s*/gm, '')) {
-                    return;
-                }
-                context.report({
-                    node: node,
-                    messageId: 'noLiteralStringInJsx',
-                });
-            },
-            // Children expression container
-            'JSXElement > JSXExpressionContainer': (node) => {
-                if (node.expression.type !== 'JSXEmptyExpression') {
-                    checkJSXExpression(node.expression);
-                }
-            },
-        };
-    },
-};

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

@@ -1,9 +0,0 @@
-import { RuleModule } from '@typescript-eslint/utils/ts-eslint';
-type MessageIds = 'untranslatedProperty';
-type PropertyConfig = {
-    include: string[];
-};
-type Options = [PropertyConfig?];
-export declare const name = "no-literal-string-in-object";
-export declare const rule: RuleModule<MessageIds, Options>;
-export {};

package/lib_esnext/rules/no-literal-string-in-object.js

@@ -1,90 +0,0 @@
-import { TSESTree } from '@typescript-eslint/utils';
-import { getParserServices } from '../context-compat';
-export const name = 'no-literal-string-in-object';
-export const rule = {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Enforce translation of specific object properties',
-            url: 'https://formatjs.github.io/docs/tooling/linter#no-literal-string-in-object',
-        },
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    include: {
-                        type: 'array',
-                        items: { type: 'string' },
-                        default: ['label'],
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-        messages: {
-            untranslatedProperty: 'Object property: `{{propertyKey}}` might contain an untranslated literal string',
-        },
-    },
-    defaultOptions: [],
-    create(context) {
-        const propertyVisitor = (node) => {
-            checkProperty(context, node);
-        };
-        const parserServices = getParserServices(context);
-        //@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
-        if (parserServices?.defineTemplateBodyVisitor) {
-            //@ts-expect-error
-            return parserServices.defineTemplateBodyVisitor({
-                Property: propertyVisitor,
-            }, {
-                Property: propertyVisitor,
-            });
-        }
-        return {
-            Property: propertyVisitor,
-        };
-    },
-};
-function checkProperty(context, node) {
-    const config = {
-        include: ['label'],
-        ...(context.options[0] || {}),
-    };
-    const propertyKey = node.key.type === TSESTree.AST_NODE_TYPES.Identifier
-        ? node.key.name
-        : node.key.type === TSESTree.AST_NODE_TYPES.Literal &&
-            typeof node.key.value === 'string'
-            ? node.key.value
-            : null;
-    if (!propertyKey || !config.include.includes(propertyKey)) {
-        return;
-    }
-    checkPropertyValue(context, node.value, propertyKey);
-}
-function checkPropertyValue(context, node, propertyKey) {
-    if ((node.type === 'Literal' &&
-        typeof node.value === 'string' &&
-        node.value.length > 0) ||
-        (node.type === 'TemplateLiteral' &&
-            (node.quasis.length > 1 || node.quasis[0].value.raw.length > 0))) {
-        context.report({
-            node: node,
-            messageId: 'untranslatedProperty',
-            data: {
-                propertyKey: propertyKey,
-            },
-        });
-    }
-    else if (node.type === 'BinaryExpression' && node.operator === '+') {
-        checkPropertyValue(context, node.left, propertyKey);
-        checkPropertyValue(context, node.right, propertyKey);
-    }
-    else if (node.type === 'ConditionalExpression') {
-        checkPropertyValue(context, node.consequent, propertyKey);
-        checkPropertyValue(context, node.alternate, propertyKey);
-    }
-    else if (node.type === 'LogicalExpression') {
-        checkPropertyValue(context, node.left, propertyKey);
-        checkPropertyValue(context, node.right, propertyKey);
-    }
-}

package/lib_esnext/rules/no-missing-icu-plural-one-placeholders.d.ts

@@ -1,6 +0,0 @@
-import { RuleModule } from '@typescript-eslint/utils/ts-eslint';
-export declare const name = "no-missing-icu-plural-one-placeholders";
-export type MessageIds = 'noMissingIcuPluralOnePlaceholders';
-type Options = [];
-export declare const rule: RuleModule<MessageIds, Options>;
-export {};

package/lib_esnext/rules/no-missing-icu-plural-one-placeholders.js

@@ -1,99 +0,0 @@
-import { isLiteralElement, isPluralElement, isSelectElement, isTagElement, parse, } from '@formatjs/icu-messageformat-parser';
-import MagicString from 'magic-string';
-import { getParserServices } from '../context-compat';
-import { extractMessages, patchMessage } from '../util';
-export const name = 'no-missing-icu-plural-one-placeholders';
-function verifyAst(context, messageNode, ast) {
-    const patches = [];
-    _verifyAstAndReplace(ast);
-    if (patches.length > 0) {
-        const patchedMessage = patchMessage(messageNode, ast, content => {
-            return patches
-                .reduce((magicString, patch) => {
-                switch (patch.type) {
-                    case 'prependLeft':
-                        return magicString.prependLeft(patch.index, patch.content);
-                    case 'remove':
-                        return magicString.remove(patch.start, patch.end);
-                    case 'update':
-                        return magicString.update(patch.start, patch.end, patch.content);
-                }
-            }, new MagicString(content))
-                .toString();
-        });
-        context.report({
-            node: messageNode,
-            messageId: 'noMissingIcuPluralOnePlaceholders',
-            fix: patchedMessage !== null
-                ? fixer => fixer.replaceText(messageNode, patchedMessage)
-                : null,
-        });
-    }
-    function _verifyAstAndReplace(ast, root = true) {
-        for (const el of ast) {
-            if (isPluralElement(el) && el.options['one']) {
-                _verifyAstAndReplace(el.options['one'].value, false);
-            }
-            else if (isSelectElement(el)) {
-                for (const { value } of Object.values(el.options)) {
-                    _verifyAstAndReplace(value, root);
-                }
-            }
-            else if (isTagElement(el)) {
-                _verifyAstAndReplace(el.children, root);
-            }
-            else if (!root && isLiteralElement(el)) {
-                const match = el.value.match(/\b1\b/);
-                if (match && el.location) {
-                    patches.push({
-                        type: 'update',
-                        start: el.location.start.offset,
-                        end: el.location.end.offset,
-                        content: el.value.replace(match[0], '#'),
-                    });
-                }
-            }
-        }
-    }
-}
-function checkNode(context, node) {
-    const msgs = extractMessages(node);
-    for (const [{ message: { defaultMessage }, messageNode, },] of msgs) {
-        if (!defaultMessage || !messageNode) {
-            continue;
-        }
-        verifyAst(context, messageNode, parse(defaultMessage, { captureLocation: true }));
-    }
-}
-export const rule = {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'We use `one {# item}` instead of `one {1 item}` in ICU messages as some locales use the `one` formatting for other similar numbers.',
-            url: 'https://formatjs.github.io/docs/tooling/linter#no-explicit-icu-plural',
-        },
-        fixable: 'code',
-        messages: {
-            noMissingIcuPluralOnePlaceholders: 'Use `one {# item}` instead of `one {1 item}` in ICU messages.',
-        },
-        schema: [],
-    },
-    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-multiple-plurals.d.ts

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

package/lib_esnext/rules/no-multiple-plurals.js

@@ -1,70 +0,0 @@
-import { isPluralElement, parse, } from '@formatjs/icu-messageformat-parser';
-import { getParserServices } from '../context-compat';
-import { extractMessages, getSettings } from '../util';
-function verifyAst(ast, pluralCount = { count: 0 }) {
-    const errors = [];
-    for (const el of ast) {
-        if (isPluralElement(el)) {
-            pluralCount.count++;
-            if (pluralCount.count > 1) {
-                errors.push({ messageId: 'noMultiplePlurals', data: {} });
-            }
-            const { options } = el;
-            for (const selector of Object.keys(options)) {
-                errors.push(...verifyAst(options[selector].value, pluralCount));
-            }
-        }
-    }
-    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,
-                ...error,
-            });
-        }
-    }
-}
-export const name = 'no-multiple-plurals';
-export const rule = {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Disallow multiple plural rules in the same message',
-            url: 'https://formatjs.github.io/docs/tooling/linter#no-multiple-plurals',
-        },
-        fixable: 'code',
-        schema: [],
-        messages: {
-            noMultiplePlurals: 'Multiple plural rules in the same 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-multiple-whitespaces.d.ts

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

package/lib_esnext/rules/no-multiple-whitespaces.js

@@ -1,141 +0,0 @@
-import { parse, TYPE, } from '@formatjs/icu-messageformat-parser';
-import { getParserServices } from '../context-compat';
-import { extractMessages, getSettings, patchMessage } from '../util';
-function isAstValid(ast) {
-    for (const element of ast) {
-        switch (element.type) {
-            case TYPE.literal:
-                if (/\s{2,}/gm.test(element.value)) {
-                    return false;
-                }
-                break;
-            case TYPE.argument:
-            case TYPE.date:
-            case TYPE.literal:
-            case TYPE.number:
-            case TYPE.pound:
-            case TYPE.time:
-                break;
-            case TYPE.plural:
-            case TYPE.select: {
-                for (const option of Object.values(element.options)) {
-                    if (!isAstValid(option.value)) {
-                        return false;
-                    }
-                }
-                break;
-            }
-            case TYPE.tag:
-                return isAstValid(element.children);
-        }
-    }
-    return true;
-}
-function trimMultiWhitespaces(message, ast) {
-    const literalElements = [];
-    const collectLiteralElements = (elements) => {
-        for (const element of elements) {
-            switch (element.type) {
-                case TYPE.literal:
-                    literalElements.push(element);
-                    break;
-                case TYPE.argument:
-                case TYPE.date:
-                case TYPE.literal:
-                case TYPE.number:
-                case TYPE.pound:
-                case TYPE.time:
-                    break;
-                case TYPE.plural:
-                case TYPE.select: {
-                    for (const option of Object.values(element.options)) {
-                        collectLiteralElements(option.value);
-                    }
-                    break;
-                }
-                case TYPE.tag:
-                    collectLiteralElements(element.children);
-                    break;
-            }
-        }
-    };
-    collectLiteralElements(ast);
-    // Surgically trim whitespaces in the literal element ranges.
-    // This is to preserve the original whitespaces and newlines info that are lost to parsing.
-    let trimmedFragments = [];
-    let currentOffset = 0;
-    for (const literal of literalElements) {
-        const { start, end } = literal.location;
-        const startOffset = start.offset;
-        const endOffset = end.offset;
-        trimmedFragments.push(message.slice(currentOffset, startOffset));
-        trimmedFragments.push(message.slice(startOffset, endOffset).replace(/\s{2,}/gm, ' '));
-        currentOffset = endOffset;
-    }
-    trimmedFragments.push(message.slice(currentOffset));
-    return trimmedFragments.join('');
-}
-function checkNode(context, node) {
-    const msgs = extractMessages(node, getSettings(context));
-    for (const [{ message: { defaultMessage }, messageNode, },] of msgs) {
-        if (!defaultMessage || !messageNode) {
-            continue;
-        }
-        let ast;
-        try {
-            ast = parse(defaultMessage, { captureLocation: true });
-        }
-        catch (e) {
-            context.report({
-                node: messageNode,
-                messageId: 'parserError',
-                data: { message: e instanceof Error ? e.message : String(e) },
-            });
-            return;
-        }
-        if (!isAstValid(ast)) {
-            const newMessage = patchMessage(messageNode, ast, trimMultiWhitespaces);
-            context.report({
-                node: messageNode,
-                messageId: 'noMultipleWhitespaces',
-                fix: newMessage !== null
-                    ? fixer => fixer.replaceText(messageNode, newMessage)
-                    : null,
-            });
-        }
-    }
-}
-export const name = 'no-multiple-whitespaces';
-export const rule = {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Prevents usage of multiple consecutive whitespaces in message',
-            url: 'https://formatjs.github.io/docs/tooling/linter#no-multiple-whitespaces',
-        },
-        messages: {
-            noMultipleWhitespaces: 'Multiple consecutive whitespaces are not allowed',
-            parserError: '{{message}}',
-        },
-        fixable: 'code',
-        schema: [],
-    },
-    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-offset.d.ts

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

package/lib_esnext/rules/no-offset.js

@@ -1,69 +0,0 @@
-import { isPluralElement, parse, } from '@formatjs/icu-messageformat-parser';
-import { getParserServices } from '../context-compat';
-import { extractMessages, getSettings } from '../util';
-function verifyAst(ast) {
-    const errors = [];
-    for (const el of ast) {
-        if (isPluralElement(el)) {
-            if (el.offset) {
-                errors.push({ messageId: 'noOffset', 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 name = 'no-offset';
-export const rule = {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Disallow offset in plural rules',
-            url: 'https://formatjs.github.io/docs/tooling/linter#no-offset',
-        },
-        fixable: 'code',
-        messages: {
-            noOffset: 'offset is not allowed',
-        },
-        schema: [],
-    },
-    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,
-        };
-    },
-};