eslint-plugin-formatjs 4.11.2 → 4.12.0

package/rules/enforce-id.js

@@ -1,27 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = exports.name = void 0;
 const ts_transformer_1 = require("@formatjs/ts-transformer");
 const util_1 = require("../util");
-function checkNode(context, node, { idInterpolationPattern, idWhitelistRegexps }) {
+function checkNode(context, node, { idInterpolationPattern, idWhitelistRegexps, }) {
     const msgs = (0, util_1.extractMessages)(node, (0, util_1.getSettings)(context));
     for (const [{ message: { defaultMessage, description, id }, idPropNode, descriptionNode, messagePropNode, },] of msgs) {
         if (!idInterpolationPattern && !idPropNode) {
             context.report({
-                node: node,
-                message: `id must be specified`,
+                node,
+                messageId: 'enforceId',
             });
         }
         else if (idInterpolationPattern) {
             if (!defaultMessage) {
                 context.report({
-                    node: node,
-                    message: `defaultMessage must be a string literal to calculate generated IDs`,
+                    node,
+                    messageId: 'enforceIdDefaultMessage',
                 });
             }
             else if (!description && descriptionNode) {
                 context.report({
-                    node: node,
-                    message: `description must be a string literal to calculate generated IDs`,
+                    node,
+                    messageId: 'enforceIdDescription',
                 });
             }
             else {
@@ -39,17 +40,25 @@ function checkNode(context, node, { idInterpolationPattern, idWhitelistRegexps }
                         : defaultMessage,
                 });
                 if (id !== correctId) {
-                    let message = `"id" does not match with hash pattern ${idInterpolationPattern}`;
+                    let messageId = 'enforceIdMatching';
+                    let messageData = {
+                        idInterpolationPattern,
+                        expected: correctId,
+                        actual: id,
+                    };
                     if (idWhitelistRegexps) {
-                        message += ` or allowlisted patterns ["${idWhitelistRegexps
-                            .map(r => r.toString())
-                            .join('", "')}"]`;
+                        messageId = 'enforceIdMatchingAllowlisted';
+                        messageData = {
+                            ...messageData,
+                            idWhitelist: idWhitelistRegexps
+                                .map(r => `"${r.toString()}"`)
+                                .join(', '),
+                        };
                     }
                     context.report({
-                        node: node,
-                        message: `${message}.
-Expected: ${correctId}
-Actual: ${id}`,
+                        node,
+                        messageId,
+                        data: messageData,
                         fix(fixer) {
                             if (idPropNode) {
                                 if (idPropNode.type === 'JSXAttribute') {
@@ -57,11 +66,14 @@ Actual: ${id}`,
                                 }
                                 return fixer.replaceText(idPropNode, `id: '${correctId}'`);
                             }
-                            // Insert after default message node
-                            if (messagePropNode.type === 'JSXAttribute') {
-                                return fixer.insertTextAfter(messagePropNode, ` 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 fixer.insertTextAfter(messagePropNode, `, id: '${correctId}'`);
+                            return null;
                         },
                     });
                 }
@@ -69,13 +81,12 @@ Actual: ${id}`,
         }
     }
 }
-exports.default = {
+exports.name = 'enforce-id';
+exports.rule = {
     meta: {
         type: 'problem',
         docs: {
             description: 'Enforce (generated) ID in message descriptor',
-            category: 'Errors',
-            recommended: false,
             url: 'https://formatjs.io/docs/tooling/linter#enforce-id',
         },
         fixable: 'code',
@@ -99,10 +110,26 @@ exports.default = {
                 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];
-        const opts = {
+        const tmp = context.options[0];
+        let opts = {
             idInterpolationPattern: tmp?.idInterpolationPattern,
         };
         if (Array.isArray(tmp?.idWhitelist)) {
@@ -110,7 +137,9 @@ exports.default = {
             opts.idWhitelistRegexps = idWhitelist.map((str) => new RegExp(str, 'i'));
         }
         const callExpressionVisitor = (node) => checkNode(context, node, opts);
+        //@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
         if (context.parserServices.defineTemplateBodyVisitor) {
+            //@ts-expect-error
             return context.parserServices.defineTemplateBodyVisitor({
                 CallExpression: callExpressionVisitor,
             }, {

package/rules/enforce-placeholders.d.ts

@@ -1,3 +1,8 @@
-import { Rule } from 'eslint';
-declare const rule: Rule.RuleModule;
-export default rule;
+import { RuleModule, RuleListener } 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, RuleListener>;
+export {};

package/rules/enforce-placeholders.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = exports.name = void 0;
 const icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
 const util_1 = require("../util");
 function collectPlaceholderNames(ast) {
@@ -68,7 +69,8 @@ function checkNode(context, node) {
         catch (e) {
             context.report({
                 node: messageNode,
-                message: e instanceof Error ? e.message : String(e),
+                messageId: 'parserError',
+                data: { message: e instanceof Error ? e.message : String(e) },
             });
             continue;
         }
@@ -82,26 +84,28 @@ function checkNode(context, node) {
         if (missingPlaceholders.length > 0) {
             context.report({
                 node: messageNode,
-                message: `Missing value(s) for the following placeholder(s): ${missingPlaceholders.join(', ')}.`,
+                messageId: 'missingValue',
+                data: {
+                    list: missingPlaceholders.join(', '),
+                },
             });
         }
         literalElementByLiteralKey.forEach((element, key) => {
             if (!ignoreList.has(key) && !placeholderNames.has(key)) {
                 context.report({
                     node: element,
-                    message: 'Value not used by the message.',
+                    messageId: 'unusedValue',
                 });
             }
         });
     }
 }
-const rule = {
+exports.name = 'enforce-placeholders';
+exports.rule = {
     meta: {
         type: 'problem',
         docs: {
             description: 'Enforce that all messages with placeholders have enough passed-in values',
-            category: 'Errors',
-            recommended: true,
             url: 'https://formatjs.io/docs/tooling/linter#enforce-placeholders',
         },
         schema: [
@@ -118,10 +122,18 @@ const rule = {
                 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);
+        //@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
         if (context.parserServices.defineTemplateBodyVisitor) {
+            //@ts-expect-error
             return context.parserServices.defineTemplateBodyVisitor({
                 CallExpression: callExpressionVisitor,
             }, {
@@ -134,4 +146,3 @@ const rule = {
         };
     },
 };
-exports.default = rule;

package/rules/enforce-plural-rules.d.ts

@@ -1,3 +1,17 @@
-import { Rule } from 'eslint';
-declare const rule: Rule.RuleModule;
-export default rule;
+import { RuleModule, RuleListener } 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, RuleListener>;
+export {};

package/rules/enforce-plural-rules.js

@@ -1,13 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = exports.name = void 0;
 const icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
 const util_1 = require("../util");
-class PluralRulesEnforcement extends Error {
-    constructor(message) {
-        super();
-        this.message = message;
-    }
-}
 var LDML;
 (function (LDML) {
     LDML["zero"] = "zero";
@@ -18,23 +13,25 @@ var LDML;
     LDML["other"] = "other";
 })(LDML || (LDML = {}));
 function verifyAst(plConfig, ast) {
+    const errors = [];
     for (const el of ast) {
         if ((0, icu_messageformat_parser_1.isPluralElement)(el)) {
             const rules = Object.keys(plConfig);
             for (const rule of rules) {
                 if (plConfig[rule] && !el.options[rule]) {
-                    throw new PluralRulesEnforcement(`Missing plural rule "${rule}"`);
+                    errors.push({ messageId: 'missingPlural', data: { rule } });
                 }
                 if (!plConfig[rule] && el.options[rule]) {
-                    throw new PluralRulesEnforcement(`Plural rule "${rule}" is forbidden`);
+                    errors.push({ messageId: 'forbidden', data: { rule } });
                 }
             }
             const { options } = el;
             for (const selector of Object.keys(options)) {
-                verifyAst(plConfig, options[selector].value);
+                errors.push(...verifyAst(plConfig, options[selector].value));
             }
         }
     }
+    return errors;
 }
 function checkNode(context, node) {
     const settings = (0, util_1.getSettings)(context);
@@ -50,26 +47,23 @@ function checkNode(context, node) {
         if (!defaultMessage || !messageNode) {
             continue;
         }
-        try {
-            verifyAst(context.options[0], (0, icu_messageformat_parser_1.parse)(defaultMessage, {
-                ignoreTag: settings.ignoreTag,
-            }));
-        }
-        catch (e) {
+        const errors = verifyAst(plConfig, (0, icu_messageformat_parser_1.parse)(defaultMessage, {
+            ignoreTag: settings.ignoreTag,
+        }));
+        for (const error of errors) {
             context.report({
                 node: messageNode,
-                message: e instanceof Error ? e.message : String(e),
+                ...error,
             });
         }
     }
 }
-const rule = {
+exports.name = 'enforce-plural-rules';
+exports.rule = {
     meta: {
         type: 'problem',
         docs: {
             description: 'Enforce plural rules to always specify certain categories like `one`/`other`',
-            category: 'Errors',
-            recommended: false,
             url: 'https://formatjs.io/docs/tooling/linter#enforce-plural-rules',
         },
         fixable: 'code',
@@ -85,10 +79,17 @@ const rule = {
                 additionalProperties: false,
             },
         ],
+        messages: {
+            missingPlural: `Missing plural rule "{{rule}}"`,
+            forbidden: `Plural rule "{{rule}}" is forbidden`,
+        },
     },
+    defaultOptions: [],
     create(context) {
         const callExpressionVisitor = (node) => checkNode(context, node);
+        //@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
         if (context.parserServices.defineTemplateBodyVisitor) {
+            //@ts-expect-error
             return context.parserServices.defineTemplateBodyVisitor({
                 CallExpression: callExpressionVisitor,
             }, {
@@ -101,4 +102,3 @@ const rule = {
         };
     },
 };
-exports.default = rule;

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

@@ -1,3 +1,6 @@
-import { Rule } from 'eslint';
-declare const rule: Rule.RuleModule;
-export default rule;
+import { RuleModule, RuleListener } from '@typescript-eslint/utils/ts-eslint';
+type MessageIds = 'camelcase';
+type Options = [Element[]?];
+export declare const name = "no-camel-case";
+export declare const rule: RuleModule<MessageIds, Options, RuleListener>;
+export {};

package/rules/no-camel-case.js

@@ -1,32 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = exports.name = void 0;
 const icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
 const util_1 = require("../util");
+exports.name = 'no-camel-case';
 const CAMEL_CASE_REGEX = /[A-Z]/;
-class CamelCase extends Error {
-    constructor() {
-        super(...arguments);
-        this.message = 'Camel case arguments are not allowed';
-    }
-}
 function verifyAst(ast) {
+    const errors = [];
     for (const el of ast) {
         if ((0, icu_messageformat_parser_1.isArgumentElement)(el)) {
             if (CAMEL_CASE_REGEX.test(el.value)) {
-                throw new CamelCase();
+                errors.push({ messageId: 'camelcase', data: {} });
             }
             continue;
         }
         if ((0, icu_messageformat_parser_1.isPluralElement)(el)) {
             if (CAMEL_CASE_REGEX.test(el.value)) {
-                throw new CamelCase();
+                errors.push({ messageId: 'camelcase', data: {} });
             }
             const { options } = el;
             for (const selector of Object.keys(options)) {
-                verifyAst(options[selector].value);
+                errors.push(...verifyAst(options[selector].value));
             }
         }
     }
+    return errors;
 }
 function checkNode(context, node) {
     const settings = (0, util_1.getSettings)(context);
@@ -35,33 +33,36 @@ function checkNode(context, node) {
         if (!defaultMessage || !messageNode) {
             continue;
         }
-        try {
-            verifyAst((0, icu_messageformat_parser_1.parse)(defaultMessage, {
-                ignoreTag: settings.ignoreTag,
-            }));
-        }
-        catch (e) {
+        const errors = verifyAst((0, icu_messageformat_parser_1.parse)(defaultMessage, {
+            ignoreTag: settings.ignoreTag,
+        }));
+        for (const error of errors) {
             context.report({
                 node: messageNode,
-                message: e instanceof Error ? e.message : String(e),
+                ...error,
             });
         }
     }
 }
-const rule = {
+exports.rule = {
     meta: {
         type: 'problem',
         docs: {
             description: 'Disallow camel case placeholders in message',
-            category: 'Errors',
-            recommended: false,
             url: 'https://formatjs.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);
+        //@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
         if (context.parserServices.defineTemplateBodyVisitor) {
+            //@ts-expect-error
             return context.parserServices.defineTemplateBodyVisitor({
                 CallExpression: callExpressionVisitor,
             }, {
@@ -74,4 +75,3 @@ const rule = {
         };
     },
 };
-exports.default = rule;

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

@@ -1,3 +1,9 @@
-import { Rule } from 'eslint';
-declare const rule: Rule.RuleModule;
-export default rule;
+import { RuleModule, RuleListener } 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, RuleListener>;
+export {};

package/rules/no-complex-selectors.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = exports.name = void 0;
 const icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
 const util_1 = require("../util");
 function calculateComplexity(ast) {
@@ -65,29 +66,26 @@ function checkNode(context, node) {
         catch (e) {
             context.report({
                 node: messageNode,
-                message: e instanceof Error ? e.message : String(e),
+                messageId: 'parserError',
+                data: { message: e instanceof Error ? e.message : String(e) },
             });
             return;
         }
-        let complexity = 0;
-        try {
-            complexity = calculateComplexity(ast);
-        }
-        catch (e) {
-            context.report({
-                node: messageNode,
-                message: e instanceof Error ? e.message : e,
-            });
-        }
+        const complexity = calculateComplexity(ast);
         if (complexity > config.limit) {
             context.report({
                 node: messageNode,
-                message: `Message complexity is too high (${complexity} vs limit at ${config.limit})`,
+                messageId: 'tooComplex',
+                data: {
+                    complexity,
+                    limit: config.limit,
+                },
             });
         }
     }
 }
-const rule = {
+exports.name = 'no-complex-selectors';
+exports.rule = {
     meta: {
         type: 'problem',
         docs: {
@@ -100,8 +98,6 @@ 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)
 `,
-            category: 'Errors',
-            recommended: false,
             url: 'https://formatjs.io/docs/tooling/linter#no-complex-selectors',
         },
         schema: [
@@ -116,10 +112,17 @@ Default complexity limit is 20
             },
         ],
         fixable: 'code',
+        messages: {
+            tooComplex: `Message complexity is too high ({{complexity}} vs limit at {{limit}})`,
+            parserError: '{{meesage}}',
+        },
     },
+    defaultOptions: [{ limit: 20 }],
     create(context) {
         const callExpressionVisitor = (node) => checkNode(context, node);
+        //@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
         if (context.parserServices.defineTemplateBodyVisitor) {
+            //@ts-expect-error
             return context.parserServices.defineTemplateBodyVisitor({
                 CallExpression: callExpressionVisitor,
             }, {
@@ -132,4 +135,3 @@ Default complexity limit is 20
         };
     },
 };
-exports.default = rule;

package/rules/no-emoji.d.ts

@@ -1,3 +1,9 @@
-import { Rule } from 'eslint';
-declare const rule: Rule.RuleModule;
-export default rule;
+import { RuleModule, RuleListener } 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, RuleListener>;
+export {};

package/rules/no-emoji.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = exports.name = void 0;
 const unicode_emoji_utils_1 = require("unicode-emoji-utils");
 const util_1 = require("../util");
+exports.name = 'no-emoji';
 function checkNode(context, node) {
     const msgs = (0, util_1.extractMessages)(node, (0, util_1.getSettings)(context));
     let allowedEmojis = [];
@@ -58,13 +60,11 @@ const versionAboveEnums = [
     '14.0',
     '15.0',
 ];
-const rule = {
+exports.rule = {
     meta: {
         type: 'problem',
         docs: {
             description: 'Disallow emojis in message',
-            category: 'Errors',
-            recommended: false,
             url: 'https://formatjs.io/docs/tooling/linter#no-emoji',
         },
         fixable: 'code',
@@ -80,9 +80,12 @@ const rule = {
             notAllowedAboveVersion: 'Emojis above version {{versionAbove}} are not allowed - Emoji: {{emoji}}',
         },
     },
+    defaultOptions: [],
     create(context) {
         const callExpressionVisitor = (node) => checkNode(context, node);
+        //@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
         if (context.parserServices.defineTemplateBodyVisitor) {
+            //@ts-expect-error
             return context.parserServices.defineTemplateBodyVisitor({
                 CallExpression: callExpressionVisitor,
             }, {
@@ -95,4 +98,3 @@ const rule = {
         };
     },
 };
-exports.default = rule;

package/rules/no-id.d.ts

@@ -1,3 +1,6 @@
-import { Rule } from 'eslint';
-declare const _default: Rule.RuleModule;
-export default _default;
+import { RuleModule, RuleListener } from '@typescript-eslint/utils/ts-eslint';
+type MessageIds = 'noId';
+type Options = [];
+export declare const name = "no-id";
+export declare const rule: RuleModule<MessageIds, Options, RuleListener>;
+export {};

package/rules/no-id.js

@@ -1,16 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = exports.name = void 0;
 const util_1 = require("../util");
 function isComment(token) {
     return !!token && (token.type === 'Block' || token.type === 'Line');
 }
+exports.name = 'no-id';
 function checkNode(context, node) {
     const msgs = (0, util_1.extractMessages)(node, (0, util_1.getSettings)(context));
     for (const [{ idPropNode }] of msgs) {
         if (idPropNode) {
             context.report({
                 node: idPropNode,
-                message: 'Manual `id` are not allowed in message descriptor',
+                messageId: 'noId',
                 fix(fixer) {
                     const src = context.getSourceCode();
                     const token = src.getTokenAfter(idPropNode);
@@ -24,20 +26,25 @@ function checkNode(context, node) {
         }
     }
 }
-exports.default = {
+exports.rule = {
     meta: {
         type: 'problem',
         docs: {
             description: 'Ban explicit ID from MessageDescriptor',
-            category: 'Errors',
-            recommended: false,
             url: 'https://formatjs.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);
+        //@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
         if (context.parserServices.defineTemplateBodyVisitor) {
+            //@ts-expect-error
             return context.parserServices.defineTemplateBodyVisitor({
                 CallExpression: callExpressionVisitor,
             }, {