eslint-plugin-formatjs 4.11.3 → 4.12.1

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,
             }, {

package/rules/no-invalid-icu.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 = 'icuError';
+type Options = [];
+export declare const name = "no-invalid-icu";
+export declare const rule: RuleModule<MessageIds, Options, RuleListener>;
+export {};

package/rules/no-invalid-icu.js

@@ -1,7 +1,9 @@
 "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-invalid-icu';
 function checkNode(context, node) {
     const settings = (0, util_1.getSettings)(context);
     const msgs = (0, util_1.extractMessages)(node, settings);
@@ -21,24 +23,30 @@ function checkNode(context, node) {
             const msg = e instanceof Error ? e.message : e;
             context.report({
                 node: messageNode,
-                message: `Error parsing ICU string: ${msg}`,
+                messageId: 'icuError',
+                data: { message: `Error parsing ICU string: ${msg}` },
             });
         }
     }
 }
-const rule = {
+exports.rule = {
     meta: {
         type: 'problem',
         docs: {
             description: `Make sure ICU messages are formatted correctly with no bad select statements, plurals, etc.`,
-            category: 'Errors',
-            recommended: true,
         },
         fixable: 'code',
+        schema: [],
+        messages: {
+            icuError: 'Invalid ICU Message format: {{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,
             }, {
@@ -51,4 +59,3 @@ const rule = {
         };
     },
 };
-exports.default = rule;

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

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

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = exports.name = void 0;
 const tslib_1 = require("tslib");
 const utils_1 = require("@typescript-eslint/utils");
 const picomatch_1 = tslib_1.__importDefault(require("picomatch"));
@@ -34,13 +35,12 @@ function compilePropMatcher(propMatcher) {
         ];
     });
 }
-const rule = {
+exports.name = 'no-literal-string-in-jsx';
+exports.rule = {
     meta: {
         type: 'problem',
         docs: {
             description: 'Disallow untranslated literal strings without translation.',
-            category: 'Errors',
-            recommended: false,
             url: 'https://formatjs.io/docs/tooling/linter#no-literal-string-in-jsx',
         },
         schema: [
@@ -61,7 +61,11 @@ const rule = {
                 },
             },
         ],
+        messages: {
+            noLiteralStringInJsx: 'Cannot have untranslated text in JSX',
+        },
     },
+    defaultOptions: [],
     // TODO: Vue support
     create(context) {
         const userConfig = context.options[0] || {};
@@ -109,7 +113,7 @@ const rule = {
                     (node.quasis.length > 1 || node.quasis[0].value.raw.length > 0))) {
                 context.report({
                     node: node,
-                    message: 'Cannot have untranslated text in JSX',
+                    messageId: 'noLiteralStringInJsx',
                 });
             }
             else if (node.type === 'BinaryExpression' && node.operator === '+') {
@@ -150,7 +154,7 @@ const rule = {
                     node.value.value.length > 0) {
                     context.report({
                         node: node,
-                        message: 'Cannot have untranslated text in JSX',
+                        messageId: 'noLiteralStringInJsx',
                     });
                 }
                 else if (node.value.type === 'JSXExpressionContainer' &&
@@ -165,7 +169,7 @@ const rule = {
                 }
                 context.report({
                     node: node,
-                    message: 'Cannot have untranslated text in JSX',
+                    messageId: 'noLiteralStringInJsx',
                 });
             },
             // Children expression container
@@ -177,4 +181,3 @@ const rule = {
         };
     },
 };
-exports.default = rule;