eslint-plugin-formatjs 5.4.1 → 6.0.0

package/lib_esnext/rules/no-useless-message.d.ts

@@ -1,5 +0,0 @@
-import { RuleModule } from '@typescript-eslint/utils/ts-eslint';
-type MessageIds = 'unnecessaryFormat' | 'unnecessaryFormatNumber' | 'unnecessaryFormatDate' | 'unnecessaryFormatTime';
-export declare const name = "no-useless-message";
-export declare const rule: RuleModule<MessageIds>;
-export {};

package/lib_esnext/rules/no-useless-message.js

@@ -1,71 +0,0 @@
-import { parse, TYPE, } from '@formatjs/icu-messageformat-parser';
-import { getParserServices } from '../context-compat';
-import { extractMessages, getSettings } from '../util';
-function verifyAst(ast) {
-    if (ast.length !== 1) {
-        return;
-    }
-    switch (ast[0].type) {
-        case TYPE.argument:
-            return 'unnecessaryFormat';
-        case TYPE.number:
-            return 'unnecessaryFormatNumber';
-        case TYPE.date:
-            return 'unnecessaryFormatDate';
-        case TYPE.time:
-            return 'unnecessaryFormatTime';
-    }
-}
-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 messageId = verifyAst(parse(defaultMessage, {
-            ignoreTag: settings.ignoreTag,
-        }));
-        if (messageId)
-            context.report({
-                node: messageNode,
-                messageId,
-            });
-    }
-}
-export const name = 'no-useless-message';
-export const rule = {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Disallow unnecessary formatted message',
-            url: 'https://formatjs.github.io/docs/tooling/linter#no-useless-message',
-        },
-        fixable: 'code',
-        schema: [],
-        messages: {
-            unnecessaryFormat: 'Unnecessary formatted message.',
-            unnecessaryFormatNumber: 'Unnecessary formatted message: just use FormattedNumber or intl.formatNumber.',
-            unnecessaryFormatDate: 'Unnecessary formatted message: just use FormattedDate or intl.formatDate.',
-            unnecessaryFormatTime: 'Unnecessary formatted message: just use FormattedTime or intl.formatTime.',
-        },
-    },
-    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/prefer-formatted-message.d.ts

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

package/lib_esnext/rules/prefer-formatted-message.js

@@ -1,33 +0,0 @@
-import { isIntlFormatMessageCall } from '../util';
-export const name = 'prefer-formatted-message';
-export const rule = {
-    meta: {
-        type: 'suggestion',
-        docs: {
-            description: 'Prefer `FormattedMessage` component over `intl.formatMessage` if applicable.',
-            url: 'https://formatjs.github.io/docs/tooling/linter#prefer-formatted-message',
-        },
-        messages: {
-            jsxChildren: 'Prefer `FormattedMessage` over `intl.formatMessage` in the JSX children expression.',
-        },
-        schema: [],
-    },
-    defaultOptions: [],
-    // TODO: Vue support
-    create(context) {
-        return {
-            JSXElement: (node) => {
-                node.children.forEach(child => {
-                    if (child.type !== 'JSXExpressionContainer' ||
-                        !isIntlFormatMessageCall(child.expression)) {
-                        return;
-                    }
-                    context.report({
-                        node: child,
-                        messageId: 'jsxChildren',
-                    });
-                });
-            },
-        };
-    },
-};

package/lib_esnext/rules/prefer-pound-in-plural.d.ts

@@ -1,5 +0,0 @@
-import { RuleModule } from '@typescript-eslint/utils/ts-eslint';
-type MessageIds = 'preferPoundInPlurals' | 'parseError';
-export declare const name = "prefer-pound-in-plural";
-export declare const rule: RuleModule<MessageIds>;
-export {};

package/lib_esnext/rules/prefer-pound-in-plural.js

@@ -1,191 +0,0 @@
-import { parse, TYPE, } from '@formatjs/icu-messageformat-parser';
-import MagicString from 'magic-string';
-import { getParserServices } from '../context-compat';
-import { extractMessages, getSettings, patchMessage } from '../util';
-function verifyAst(context, messageNode, ast) {
-    const patches = [];
-    _verifyAst(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: 'preferPoundInPlurals',
-            fix: patchedMessage !== null
-                ? fixer => fixer.replaceText(messageNode, patchedMessage)
-                : null,
-        });
-    }
-    function _verifyAst(ast) {
-        for (let i = 0; i < ast.length; i++) {
-            const current = ast[i];
-            switch (current.type) {
-                case TYPE.argument:
-                case TYPE.number: {
-                    // Applicable to only plain argument or number argument without any style
-                    if (current.type === TYPE.number && current.style) {
-                        break;
-                    }
-                    const next = ast[i + 1];
-                    const nextNext = ast[i + 2];
-                    if (next &&
-                        nextNext &&
-                        next.type === TYPE.literal &&
-                        next.value === ' ' &&
-                        nextNext.type === TYPE.plural &&
-                        nextNext.value === current.value) {
-                        // `{A} {A, plural, one {B} other {Bs}}` => `{A, plural, one {# B} other {# Bs}}`
-                        _removeRangeAndPrependPluralClauses(current.location.start.offset, next.location.end.offset, nextNext, '# ');
-                    }
-                    else if (next &&
-                        next.type === TYPE.plural &&
-                        next.value === current.value) {
-                        // `{A}{A, plural, one {B} other {Bs}}` => `{A, plural, one {#B} other {#Bs}}`
-                        _removeRangeAndPrependPluralClauses(current.location.start.offset, current.location.end.offset, next, '#');
-                    }
-                    break;
-                }
-                case TYPE.plural: {
-                    // `{A, plural, one {{A} B} other {{A} Bs}}` => `{A, plural, one {# B} other {# Bs}}`
-                    const name = current.value;
-                    for (const { value } of Object.values(current.options)) {
-                        _replacementArgumentWithPound(name, value);
-                    }
-                    break;
-                }
-                case TYPE.select: {
-                    for (const { value } of Object.values(current.options)) {
-                        _verifyAst(value);
-                    }
-                    break;
-                }
-                case TYPE.tag:
-                    _verifyAst(current.children);
-                    break;
-                default:
-                    break;
-            }
-        }
-    }
-    // Replace plain argument of number argument w/o style option that matches
-    // the name with a pound sign.
-    function _replacementArgumentWithPound(name, ast) {
-        for (const element of ast) {
-            switch (element.type) {
-                case TYPE.argument:
-                case TYPE.number: {
-                    if (element.value === name &&
-                        // Either plain argument or number argument without any style
-                        (element.type !== TYPE.number || !element.style)) {
-                        patches.push({
-                            type: 'update',
-                            start: element.location.start.offset,
-                            end: element.location.end.offset,
-                            content: '#',
-                        });
-                    }
-                    break;
-                }
-                case TYPE.tag: {
-                    _replacementArgumentWithPound(name, element.children);
-                    break;
-                }
-                case TYPE.select: {
-                    for (const { value } of Object.values(element.options)) {
-                        _replacementArgumentWithPound(name, value);
-                    }
-                    break;
-                }
-                default:
-                    break;
-            }
-        }
-    }
-    // Helper to remove a certain text range and then prepend the specified text to
-    // each plural clause.
-    function _removeRangeAndPrependPluralClauses(rangeToRemoveStart, rangeToRemoveEnd, pluralElement, prependText) {
-        // Delete both the `{A}` and ` `
-        patches.push({
-            type: 'remove',
-            start: rangeToRemoveStart,
-            end: rangeToRemoveEnd,
-        });
-        // Insert `# ` to the beginning of every option clause
-        for (const { location } of Object.values(pluralElement.options)) {
-            // location marks the entire clause with the surrounding braces
-            patches.push({
-                type: 'prependLeft',
-                index: location.start.offset + 1,
-                content: prependText,
-            });
-        }
-    }
-}
-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: 'parseError',
-                data: { message: e instanceof Error ? e.message : String(e) },
-            });
-            return;
-        }
-        verifyAst(context, messageNode, ast);
-    }
-}
-export const name = 'prefer-pound-in-plural';
-export const rule = {
-    meta: {
-        type: 'suggestion',
-        docs: {
-            description: 'Prefer using # to reference the count in the plural argument.',
-            url: 'https://formatjs.github.io/docs/tooling/linter#prefer-pound-in-plurals',
-        },
-        messages: {
-            preferPoundInPlurals: 'Prefer using # to reference the count in the plural argument instead of repeating the argument.',
-            parseError: '{{message}}',
-        },
-        fixable: 'code',
-        schema: [],
-    },
-    defaultOptions: [],
-    // TODO: Vue support
-    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/util.d.ts

@@ -1,32 +0,0 @@
-import { MessageFormatElement } from '@formatjs/icu-messageformat-parser';
-import { TSESTree } from '@typescript-eslint/utils';
-import { RuleContext } from '@typescript-eslint/utils/ts-eslint';
-export interface MessageDescriptor {
-    id?: string;
-    defaultMessage?: string;
-    description?: string | object;
-}
-export interface Settings {
-    excludeMessageDeclCalls?: boolean;
-    additionalFunctionNames?: string[];
-    additionalComponentNames?: string[];
-    ignoreTag?: boolean;
-}
-export interface MessageDescriptorNodeInfo {
-    message: MessageDescriptor;
-    messageNode?: TSESTree.Property['value'] | TSESTree.JSXAttribute['value'];
-    messagePropNode?: TSESTree.Property | TSESTree.JSXAttribute;
-    descriptionNode?: TSESTree.Property['value'] | TSESTree.JSXAttribute['value'];
-    idValueNode?: TSESTree.Property['value'] | TSESTree.JSXAttribute['value'];
-    idPropNode?: TSESTree.Property | TSESTree.JSXAttribute;
-}
-export declare function getSettings<TMessageIds extends string, TOptions extends readonly unknown[]>({ settings }: RuleContext<TMessageIds, TOptions>): Settings;
-export declare function isIntlFormatMessageCall(node: TSESTree.Node): node is TSESTree.CallExpression;
-export declare function extractMessageDescriptor(node?: TSESTree.Expression): MessageDescriptorNodeInfo | undefined;
-export declare function extractMessages(node: TSESTree.Node, { additionalComponentNames, additionalFunctionNames, excludeMessageDeclCalls, }?: Settings): Array<[MessageDescriptorNodeInfo, TSESTree.Expression | undefined]>;
-/**
- * Apply changes to the ICU message in code. The return value can be used in
- * `fixer.replaceText(messageNode, <return value>)`. If the return value is null,
- * it means that the patch cannot be applied.
- */
-export declare function patchMessage(messageNode: TSESTree.Node, ast: MessageFormatElement[], patcher: (messageContent: string, ast: MessageFormatElement[]) => string): string | null;

package/lib_esnext/util.js

@@ -1,280 +0,0 @@
-const FORMAT_FUNCTION_NAMES = new Set(['$formatMessage', 'formatMessage', '$t']);
-const COMPONENT_NAMES = new Set(['FormattedMessage']);
-const DECLARATION_FUNCTION_NAMES = new Set(['defineMessage']);
-export function getSettings({ settings }) {
-    return settings.formatjs ?? settings;
-}
-function isStringLiteral(node) {
-    return node.type === 'Literal' && typeof node.value === 'string';
-}
-function isTemplateLiteralWithoutVar(node) {
-    return node.type === 'TemplateLiteral' && node.quasis.length === 1;
-}
-function staticallyEvaluateStringConcat(node) {
-    if (!isStringLiteral(node.right)) {
-        return ['', false];
-    }
-    if (isStringLiteral(node.left)) {
-        return [String(node.left.value) + node.right.value, true];
-    }
-    if (node.left.type === 'BinaryExpression') {
-        const [result, isStaticallyEvaluatable] = staticallyEvaluateStringConcat(node.left);
-        return [result + node.right.value, isStaticallyEvaluatable];
-    }
-    return ['', false];
-}
-export function isIntlFormatMessageCall(node) {
-    return (node.type === 'CallExpression' &&
-        node.callee.type === 'MemberExpression' &&
-        ((node.callee.object.type === 'Identifier' &&
-            node.callee.object.name === 'intl') ||
-            (node.callee.object.type === 'MemberExpression' &&
-                node.callee.object.property.type === 'Identifier' &&
-                node.callee.object.property.name === 'intl')) &&
-        node.callee.property.type === 'Identifier' &&
-        (node.callee.property.name === 'formatMessage' ||
-            node.callee.property.name === '$t') &&
-        node.arguments.length >= 1 &&
-        node.arguments[0].type === 'ObjectExpression');
-}
-function isSingleMessageDescriptorDeclaration(node, functionNames) {
-    return (node.type === 'CallExpression' &&
-        node.callee.type === 'Identifier' &&
-        functionNames.has(node.callee.name));
-}
-function isMultipleMessageDescriptorDeclaration(node) {
-    return (node.type === 'CallExpression' &&
-        node.callee.type === 'Identifier' &&
-        node.callee.name === 'defineMessages');
-}
-export function extractMessageDescriptor(node) {
-    if (!node || node.type !== 'ObjectExpression') {
-        return;
-    }
-    const result = {
-        message: {},
-        messageNode: undefined,
-        messagePropNode: undefined,
-        descriptionNode: undefined,
-        idValueNode: undefined,
-    };
-    for (const prop of node.properties) {
-        if (prop.type !== 'Property' || prop.key.type !== 'Identifier') {
-            continue;
-        }
-        const valueNode = prop.value;
-        let value = undefined;
-        if (isStringLiteral(valueNode)) {
-            value = valueNode.value;
-        }
-        // like "`asd`"
-        else if (isTemplateLiteralWithoutVar(valueNode)) {
-            value = valueNode.quasis[0].value.cooked;
-        }
-        // like "dedent`asd`"
-        else if (valueNode.type === 'TaggedTemplateExpression') {
-            const { quasi } = valueNode;
-            if (!isTemplateLiteralWithoutVar(quasi)) {
-                throw new Error('Tagged template expression must be no substitution');
-            }
-            value = quasi.quasis[0].value.cooked;
-        }
-        // like "`asd` + `asd`"
-        else if (valueNode.type === 'BinaryExpression') {
-            const [result, isStatic] = staticallyEvaluateStringConcat(valueNode);
-            if (isStatic) {
-                value = result;
-            }
-        }
-        switch (prop.key.name) {
-            case 'defaultMessage':
-                result.messagePropNode = prop;
-                result.messageNode = valueNode;
-                result.message.defaultMessage = value;
-                break;
-            case 'description':
-                result.descriptionNode = valueNode;
-                result.message.description = value;
-                break;
-            case 'id':
-                result.message.id = value;
-                result.idValueNode = valueNode;
-                result.idPropNode = prop;
-                break;
-        }
-    }
-    return result;
-}
-function extractMessageDescriptorFromJSXElement(node) {
-    if (!node || !node.attributes) {
-        return;
-    }
-    let values;
-    const result = {
-        message: {},
-        messageNode: undefined,
-        messagePropNode: undefined,
-        descriptionNode: undefined,
-        idValueNode: undefined,
-        idPropNode: undefined,
-    };
-    let hasSpreadAttribute = false;
-    for (const prop of node.attributes) {
-        // We can't analyze spread attr
-        if (prop.type === 'JSXSpreadAttribute') {
-            hasSpreadAttribute = true;
-        }
-        if (prop.type !== 'JSXAttribute' || prop.name.type !== 'JSXIdentifier') {
-            continue;
-        }
-        const key = prop.name;
-        let valueNode = prop.value;
-        let value = undefined;
-        if (valueNode) {
-            if (isStringLiteral(valueNode)) {
-                value = valueNode.value;
-            }
-            else if (valueNode?.type === 'JSXExpressionContainer') {
-                const { expression } = valueNode;
-                if (expression.type === 'BinaryExpression') {
-                    const [result, isStatic] = staticallyEvaluateStringConcat(expression);
-                    if (isStatic) {
-                        value = result;
-                    }
-                }
-                // like "`asd`"
-                else if (isTemplateLiteralWithoutVar(expression)) {
-                    value = expression.quasis[0].value.cooked;
-                }
-                // like "dedent`asd`"
-                else if (expression.type === 'TaggedTemplateExpression') {
-                    const { quasi } = expression;
-                    if (!isTemplateLiteralWithoutVar(quasi)) {
-                        throw new Error('Tagged template expression must be no substitution');
-                    }
-                    value = quasi.quasis[0].value.cooked;
-                }
-            }
-        }
-        switch (key.name) {
-            case 'defaultMessage':
-                result.messagePropNode = prop;
-                result.messageNode = valueNode;
-                if (value) {
-                    result.message.defaultMessage = value;
-                }
-                break;
-            case 'description':
-                result.descriptionNode = valueNode;
-                if (value) {
-                    result.message.description = value;
-                }
-                break;
-            case 'id':
-                result.idValueNode = valueNode;
-                result.idPropNode = prop;
-                if (value) {
-                    result.message.id = value;
-                }
-                break;
-            case 'values':
-                if (valueNode?.type === 'JSXExpressionContainer' &&
-                    valueNode.expression.type === 'ObjectExpression') {
-                    values = valueNode.expression;
-                }
-                break;
-        }
-    }
-    if (!result.messagePropNode &&
-        !result.descriptionNode &&
-        !result.idPropNode &&
-        hasSpreadAttribute) {
-        return;
-    }
-    return [result, values];
-}
-function extractMessageDescriptors(node) {
-    if (!node || node.type !== 'ObjectExpression' || !node.properties.length) {
-        return [];
-    }
-    const msgs = [];
-    for (const prop of node.properties) {
-        if (prop.type !== 'Property') {
-            continue;
-        }
-        const msg = prop.value;
-        if (msg.type !== 'ObjectExpression') {
-            continue;
-        }
-        const nodeInfo = extractMessageDescriptor(msg);
-        if (nodeInfo) {
-            msgs.push(nodeInfo);
-        }
-    }
-    return msgs;
-}
-export function extractMessages(node, { additionalComponentNames, additionalFunctionNames, excludeMessageDeclCalls, } = {}) {
-    const allFormatFunctionNames = Array.isArray(additionalFunctionNames)
-        ? new Set([
-            ...Array.from(FORMAT_FUNCTION_NAMES),
-            ...additionalFunctionNames,
-        ])
-        : FORMAT_FUNCTION_NAMES;
-    const allComponentNames = Array.isArray(additionalComponentNames)
-        ? new Set([...Array.from(COMPONENT_NAMES), ...additionalComponentNames])
-        : COMPONENT_NAMES;
-    if (node.type === 'CallExpression') {
-        const expr = node;
-        const args0 = expr.arguments[0];
-        const args1 = expr.arguments[1];
-        // We can't really analyze spread element
-        if (!args0 || args0.type === 'SpreadElement') {
-            return [];
-        }
-        if ((!excludeMessageDeclCalls &&
-            isSingleMessageDescriptorDeclaration(node, DECLARATION_FUNCTION_NAMES)) ||
-            isIntlFormatMessageCall(node) ||
-            isSingleMessageDescriptorDeclaration(node, allFormatFunctionNames)) {
-            const msgDescriptorNodeInfo = extractMessageDescriptor(args0);
-            if (msgDescriptorNodeInfo && (!args1 || args1.type !== 'SpreadElement')) {
-                return [[msgDescriptorNodeInfo, args1]];
-            }
-        }
-        else if (!excludeMessageDeclCalls &&
-            isMultipleMessageDescriptorDeclaration(node)) {
-            return extractMessageDescriptors(args0).map(msg => [msg, undefined]);
-        }
-    }
-    else if (node.type === 'JSXOpeningElement' &&
-        node.name &&
-        node.name.type === 'JSXIdentifier' &&
-        allComponentNames.has(node.name.name)) {
-        const msgDescriptorNodeInfo = extractMessageDescriptorFromJSXElement(node);
-        if (msgDescriptorNodeInfo) {
-            return [msgDescriptorNodeInfo];
-        }
-    }
-    return [];
-}
-/**
- * Apply changes to the ICU message in code. The return value can be used in
- * `fixer.replaceText(messageNode, <return value>)`. If the return value is null,
- * it means that the patch cannot be applied.
- */
-export function patchMessage(messageNode, ast, patcher) {
-    if (messageNode.type === 'Literal' &&
-        messageNode.value &&
-        typeof messageNode.value === 'string') {
-        return ('"' + patcher(messageNode.value, ast).replace('"', '\\"') + '"');
-    }
-    else if (messageNode.type === 'TemplateLiteral' &&
-        messageNode.quasis.length === 1 &&
-        messageNode.expressions.length === 0) {
-        return ('`' +
-            patcher(messageNode.quasis[0].value.cooked, ast)
-                .replace(/\\/g, '\\\\')
-                .replace(/`/g, '\\`') +
-            '`');
-    }
-    return null;
-}