eslint-plugin-formatjs 5.4.2 → 6.0.0

package/lib_esnext/rules/blocklist-elements.d.ts

@@ -1,15 +0,0 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const name = "blocklist-elements";
-export declare enum Element {
-    literal = "literal",
-    argument = "argument",
-    number = "number",
-    date = "date",
-    time = "time",
-    select = "select",
-    selectordinal = "selectordinal",
-    plural = "plural",
-    tag = "tag"
-}
-export declare const rule: ESLintUtils.RuleModule<'blocklist', [
-], unknown, ESLintUtils.RuleListener>;

package/lib_esnext/rules/blocklist-elements.js

@@ -1,132 +0,0 @@
-import { isArgumentElement, isDateElement, isLiteralElement, isNumberElement, isPluralElement, isSelectElement, isTagElement, isTimeElement, parse, } from '@formatjs/icu-messageformat-parser';
-import { ESLintUtils } from '@typescript-eslint/utils';
-import { getParserServices } from '../context-compat';
-import { extractMessages, getSettings } from '../util';
-export const name = 'blocklist-elements';
-function getMessage(type) {
-    return {
-        messageId: 'blocklist',
-        data: { type },
-    };
-}
-export var Element;
-(function (Element) {
-    Element["literal"] = "literal";
-    Element["argument"] = "argument";
-    Element["number"] = "number";
-    Element["date"] = "date";
-    Element["time"] = "time";
-    Element["select"] = "select";
-    Element["selectordinal"] = "selectordinal";
-    Element["plural"] = "plural";
-    Element["tag"] = "tag";
-})(Element || (Element = {}));
-function verifyAst(blocklist, ast) {
-    const errors = [];
-    for (const el of ast) {
-        if (isLiteralElement(el) && blocklist.includes(Element.literal)) {
-            errors.push(getMessage(Element.literal));
-        }
-        if (isArgumentElement(el) && blocklist.includes(Element.argument)) {
-            errors.push(getMessage(Element.argument));
-        }
-        if (isNumberElement(el) && blocklist.includes(Element.number)) {
-            errors.push(getMessage(Element.number));
-        }
-        if (isDateElement(el) && blocklist.includes(Element.date)) {
-            errors.push(getMessage(Element.date));
-        }
-        if (isTimeElement(el) && blocklist.includes(Element.time)) {
-            errors.push(getMessage(Element.time));
-        }
-        if (isSelectElement(el) && blocklist.includes(Element.select)) {
-            errors.push(getMessage(Element.select));
-        }
-        if (isTagElement(el) && blocklist.includes(Element.tag)) {
-            errors.push(getMessage(Element.tag));
-        }
-        if (isPluralElement(el)) {
-            if (blocklist.includes(Element.plural)) {
-                errors.push(getMessage(Element.argument));
-            }
-            if (el.pluralType === 'ordinal' &&
-                blocklist.includes(Element.selectordinal)) {
-                errors.push(getMessage(Element.selectordinal));
-            }
-        }
-        if (isSelectElement(el) || isPluralElement(el)) {
-            const { options } = el;
-            for (const selector of Object.keys(options)) {
-                verifyAst(blocklist, options[selector].value);
-            }
-        }
-    }
-    return errors;
-}
-function checkNode(context, node) {
-    const settings = getSettings(context);
-    const msgs = extractMessages(node, settings);
-    if (!msgs.length) {
-        return;
-    }
-    const blocklist = context.options[0];
-    if (!Array.isArray(blocklist) || !blocklist.length) {
-        return;
-    }
-    for (const [{ message: { defaultMessage }, messageNode, },] of msgs) {
-        if (!defaultMessage || !messageNode) {
-            continue;
-        }
-        const errors = verifyAst(blocklist, parse(defaultMessage, {
-            ignoreTag: settings.ignoreTag,
-        }));
-        for (const error of errors) {
-            context.report({
-                node,
-                ...error,
-            });
-        }
-    }
-}
-const createRule = ESLintUtils.RuleCreator(_ => 'https://formatjs.github.io/docs/tooling/linter#blocklist-elements');
-export const rule = createRule({
-    name,
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Disallow specific elements in ICU message format',
-            url: 'https://formatjs.github.io/docs/tooling/linter#blocklist-elements',
-        },
-        fixable: 'code',
-        schema: [
-            {
-                type: 'array',
-                items: {
-                    type: 'string',
-                    enum: Object.keys(Element),
-                },
-            },
-        ],
-        messages: {
-            blocklist: `{{type}} element is blocklisted`,
-        },
-    },
-    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/enforce-default-message.d.ts

@@ -1,10 +0,0 @@
-import { RuleModule } from '@typescript-eslint/utils/ts-eslint';
-export declare enum Option {
-    literal = "literal",
-    anything = "anything"
-}
-type MessageIds = 'defaultMessage' | 'defaultMessageLiteral';
-type Options = [`${Option}`?];
-export declare const name = "enforce-default-message";
-export declare const rule: RuleModule<MessageIds, Options>;
-export {};

package/lib_esnext/rules/enforce-default-message.js

@@ -1,68 +0,0 @@
-import { getParserServices } from '../context-compat';
-import { extractMessages, getSettings } from '../util';
-export var Option;
-(function (Option) {
-    Option["literal"] = "literal";
-    Option["anything"] = "anything";
-})(Option || (Option = {}));
-export const name = 'enforce-default-message';
-function checkNode(context, node) {
-    const msgs = extractMessages(node, getSettings(context));
-    const { options: [type], } = context;
-    for (const [{ message: { defaultMessage }, messageNode, },] of msgs) {
-        if (!defaultMessage) {
-            if (type === 'literal' && messageNode) {
-                context.report({
-                    node: messageNode,
-                    messageId: 'defaultMessageLiteral',
-                });
-            }
-            else if (!messageNode) {
-                context.report({
-                    node: node,
-                    messageId: 'defaultMessage',
-                });
-            }
-        }
-    }
-}
-export const rule = {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Enforce defaultMessage in message descriptor',
-            url: 'https://formatjs.github.io/docs/tooling/linter#enforce-default-message',
-        },
-        fixable: 'code',
-        schema: [
-            {
-                type: 'string',
-                enum: Object.keys(Option),
-            },
-        ],
-        messages: {
-            defaultMessageLiteral: `"defaultMessage" must be:
-- a string literal or
-- template literal without variable`,
-            defaultMessage: '`defaultMessage` has to be specified 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/enforce-description.d.ts

@@ -1,10 +0,0 @@
-import { RuleModule } from '@typescript-eslint/utils/ts-eslint';
-export declare enum Option {
-    literal = "literal",
-    anything = "anything"
-}
-type MessageIds = 'enforceDescription' | 'enforceDescriptionLiteral';
-type Options = [`${Option}`?];
-export declare const name = "enforce-description";
-export declare const rule: RuleModule<MessageIds, Options>;
-export {};

package/lib_esnext/rules/enforce-description.js

@@ -1,66 +0,0 @@
-import { getParserServices } from '../context-compat';
-import { extractMessages, getSettings } from '../util';
-export var Option;
-(function (Option) {
-    Option["literal"] = "literal";
-    Option["anything"] = "anything";
-})(Option || (Option = {}));
-function checkNode(context, node) {
-    const msgs = extractMessages(node, getSettings(context));
-    const { options: [type], } = context;
-    for (const [{ message: { description }, descriptionNode, },] of msgs) {
-        if (!description) {
-            if (type === 'literal' && descriptionNode) {
-                context.report({
-                    node: descriptionNode,
-                    messageId: 'enforceDescriptionLiteral',
-                });
-            }
-            else if (!descriptionNode) {
-                context.report({
-                    node: node,
-                    messageId: 'enforceDescription',
-                });
-            }
-        }
-    }
-}
-export const name = 'enforce-description';
-export const rule = {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Enforce description in message descriptor',
-            url: 'https://formatjs.github.io/docs/tooling/linter#enforce-description',
-        },
-        fixable: 'code',
-        schema: [
-            {
-                type: 'string',
-                enum: Object.keys(Option),
-            },
-        ],
-        messages: {
-            enforceDescription: '`description` has to be specified in message descriptor',
-            enforceDescriptionLiteral: '`description` has to be a string literal (not function call or variable)',
-        },
-    },
-    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/enforce-id.d.ts

@@ -1,10 +0,0 @@
-import { RuleModule } from '@typescript-eslint/utils/ts-eslint';
-export type Option = {
-    idInterpolationPattern: string;
-    idWhitelist?: string[];
-};
-type MessageIds = 'enforceId' | 'enforceIdDefaultMessage' | 'enforceIdDescription' | 'enforceIdMatching' | 'enforceIdMatchingAllowlisted';
-type Options = [Option];
-export declare const name = "enforce-id";
-export declare const rule: RuleModule<MessageIds, Options>;
-export {};

package/lib_esnext/rules/enforce-id.js

@@ -1,153 +0,0 @@
-import { interpolateName } from '@formatjs/ts-transformer';
-import { getParserServices } from '../context-compat';
-import { extractMessages, getSettings } from '../util';
-function checkNode(context, node, { idInterpolationPattern, idWhitelistRegexps, }) {
-    const msgs = extractMessages(node, getSettings(context));
-    for (const [{ message: { defaultMessage, description, id }, idPropNode, descriptionNode, messagePropNode, },] of msgs) {
-        if (!idInterpolationPattern && !idPropNode) {
-            context.report({
-                node,
-                messageId: 'enforceId',
-            });
-        }
-        else if (idInterpolationPattern) {
-            if (!defaultMessage) {
-                context.report({
-                    node,
-                    messageId: 'enforceIdDefaultMessage',
-                });
-            }
-            else if (!description && descriptionNode) {
-                context.report({
-                    node,
-                    messageId: 'enforceIdDescription',
-                });
-            }
-            else {
-                if (idWhitelistRegexps &&
-                    id &&
-                    idWhitelistRegexps.some((r) => r.test(id))) {
-                    // messageId is allowlisted so skip interpolation id check
-                    continue;
-                }
-                const correctId = interpolateName({
-                    resourcePath: context.getFilename(),
-                }, idInterpolationPattern, {
-                    content: description
-                        ? `${defaultMessage}#${description}`
-                        : defaultMessage,
-                });
-                if (id !== correctId) {
-                    let messageId = 'enforceIdMatching';
-                    let messageData = {
-                        idInterpolationPattern,
-                        expected: correctId,
-                        actual: id,
-                    };
-                    if (idWhitelistRegexps) {
-                        messageId = 'enforceIdMatchingAllowlisted';
-                        messageData = {
-                            ...messageData,
-                            idWhitelist: idWhitelistRegexps
-                                .map(r => `"${r.toString()}"`)
-                                .join(', '),
-                        };
-                    }
-                    context.report({
-                        node,
-                        messageId,
-                        data: messageData,
-                        fix(fixer) {
-                            if (idPropNode) {
-                                if (idPropNode.type === 'JSXAttribute') {
-                                    return fixer.replaceText(idPropNode, `id="${correctId}"`);
-                                }
-                                return fixer.replaceText(idPropNode, `id: '${correctId}'`);
-                            }
-                            if (messagePropNode) {
-                                // Insert after default message node
-                                if (messagePropNode.type === 'JSXAttribute') {
-                                    return fixer.insertTextAfter(messagePropNode, ` id="${correctId}"`);
-                                }
-                                return fixer.insertTextAfter(messagePropNode, `, id: '${correctId}'`);
-                            }
-                            return null;
-                        },
-                    });
-                }
-            }
-        }
-    }
-}
-export const name = 'enforce-id';
-export const rule = {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Enforce (generated) ID in message descriptor',
-            url: 'https://formatjs.github.io/docs/tooling/linter#enforce-id',
-        },
-        fixable: 'code',
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    idInterpolationPattern: {
-                        type: 'string',
-                        description: 'Pattern to verify ID against. Recommended value: [sha512:contenthash:base64:6]',
-                    },
-                    idWhitelist: {
-                        type: 'array',
-                        description: "An array of strings with regular expressions. This array allows allowlist custom ids for messages. For example '`\\\\.`' allows any id which has dot; `'^payment_.*'` - allows any custom id which has prefix `payment_`. Be aware that any backslash \\ provided via string must be escaped with an additional backslash.",
-                        items: {
-                            type: 'string',
-                        },
-                    },
-                },
-                required: ['idInterpolationPattern'],
-                additionalProperties: false,
-            },
-        ],
-        messages: {
-            enforceId: `id must be specified`,
-            enforceIdDefaultMessage: `defaultMessage must be a string literal to calculate generated IDs`,
-            enforceIdDescription: `description must be a string literal to calculate generated IDs`,
-            enforceIdMatching: `"id" does not match with hash pattern {{idInterpolationPattern}}.
-Expected: {{expected}}
-Actual: {{actual}}`,
-            enforceIdMatchingAllowlisted: `"id" does not match with hash pattern {{idInterpolationPattern}} or allowlisted patterns {{idWhitelist}}.
-Expected: {{expected}}
-Actual: {{actual}}`,
-        },
-    },
-    defaultOptions: [
-        {
-            idInterpolationPattern: '[sha512:contenthash:base64:6]',
-        },
-    ],
-    create(context) {
-        const tmp = context.options[0];
-        let opts = {
-            idInterpolationPattern: tmp?.idInterpolationPattern,
-        };
-        if (Array.isArray(tmp?.idWhitelist)) {
-            const { idWhitelist } = tmp;
-            opts.idWhitelistRegexps = idWhitelist.map((str) => new RegExp(str, 'i'));
-        }
-        const callExpressionVisitor = (node) => checkNode(context, node, opts);
-        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, opts),
-            CallExpression: callExpressionVisitor,
-        };
-    },
-};

package/lib_esnext/rules/enforce-placeholders.d.ts

@@ -1,8 +0,0 @@
-import { RuleModule } from '@typescript-eslint/utils/ts-eslint';
-type MessageIds = 'parserError' | 'missingValue' | 'unusedValue';
-type Options = [{
-    ignoreList: string[];
-}?];
-export declare const name = "enforce-placeholders";
-export declare const rule: RuleModule<MessageIds, Options>;
-export {};

package/lib_esnext/rules/enforce-placeholders.js

@@ -1,147 +0,0 @@
-import { TYPE, parse, } from '@formatjs/icu-messageformat-parser';
-import { getParserServices } from '../context-compat';
-import { extractMessages, getSettings } from '../util';
-function collectPlaceholderNames(ast) {
-    const placeholderNames = new Set();
-    _traverse(ast);
-    return placeholderNames;
-    function _traverse(ast) {
-        for (const element of ast) {
-            switch (element.type) {
-                case TYPE.literal:
-                case TYPE.pound:
-                    break;
-                case TYPE.tag:
-                    placeholderNames.add(element.value);
-                    _traverse(element.children);
-                    break;
-                case TYPE.plural:
-                case TYPE.select:
-                    placeholderNames.add(element.value);
-                    for (const { value } of Object.values(element.options)) {
-                        _traverse(value);
-                    }
-                    break;
-                default:
-                    placeholderNames.add(element.value);
-                    break;
-            }
-        }
-    }
-}
-function checkNode(context, node) {
-    const settings = getSettings(context);
-    const msgs = extractMessages(node, {
-        excludeMessageDeclCalls: true,
-        ...settings,
-    });
-    const { options: [opt], } = context;
-    const ignoreList = new Set(opt?.ignoreList || []);
-    for (const [{ message: { defaultMessage }, messageNode, }, values,] of msgs) {
-        if (!defaultMessage || !messageNode) {
-            continue;
-        }
-        if (values && values.type !== 'ObjectExpression') {
-            // cannot evaluate this
-            continue;
-        }
-        if (values?.properties.find(prop => prop.type === 'SpreadElement')) {
-            // cannot evaluate the spread element
-            continue;
-        }
-        const literalElementByLiteralKey = new Map();
-        if (values) {
-            for (const prop of values.properties) {
-                if (prop.type === 'Property' && !prop.computed) {
-                    const name = prop.key.type === 'Identifier'
-                        ? prop.key.name
-                        : String(prop.key.value);
-                    literalElementByLiteralKey.set(name, prop);
-                }
-            }
-        }
-        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) },
-            });
-            continue;
-        }
-        const placeholderNames = collectPlaceholderNames(ast);
-        const missingPlaceholders = [];
-        placeholderNames.forEach(name => {
-            if (!ignoreList.has(name) && !literalElementByLiteralKey.has(name)) {
-                missingPlaceholders.push(name);
-            }
-        });
-        if (missingPlaceholders.length > 0) {
-            context.report({
-                node: messageNode,
-                messageId: 'missingValue',
-                data: {
-                    list: missingPlaceholders.join(', '),
-                },
-            });
-        }
-        literalElementByLiteralKey.forEach((element, key) => {
-            if (!ignoreList.has(key) && !placeholderNames.has(key)) {
-                context.report({
-                    node: element,
-                    messageId: 'unusedValue',
-                });
-            }
-        });
-    }
-}
-export const name = 'enforce-placeholders';
-export const rule = {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Enforce that all messages with placeholders have enough passed-in values',
-            url: 'https://formatjs.github.io/docs/tooling/linter#enforce-placeholders',
-        },
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    ignoreList: {
-                        type: 'array',
-                        items: {
-                            type: 'string',
-                        },
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-        messages: {
-            parserError: '{{message}}',
-            missingValue: 'Missing value(s) for the following placeholder(s): {{list}}.',
-            unusedValue: 'Value not used by the 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/enforce-plural-rules.d.ts

@@ -1,17 +0,0 @@
-import { RuleModule } from '@typescript-eslint/utils/ts-eslint';
-declare enum LDML {
-    zero = "zero",
-    one = "one",
-    two = "two",
-    few = "few",
-    many = "many",
-    other = "other"
-}
-type PluralConfig = {
-    [key in LDML]?: boolean;
-};
-export type Options = [PluralConfig?];
-type MessageIds = 'missingPlural' | 'forbidden';
-export declare const name = "enforce-plural-rules";
-export declare const rule: RuleModule<MessageIds, Options>;
-export {};