eslint-plugin-formatjs 4.11.2 → 4.12.0

package/LICENSE.md

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 FormatJS
+Copyright (c) 2023 FormatJS
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/index.d.ts

@@ -1,24 +1,4 @@
-declare const plugin: {
-    rules: {
-        'blocklist-elements': import("eslint").Rule.RuleModule;
-        'enforce-default-message': import("eslint").Rule.RuleModule;
-        'enforce-description': import("eslint").Rule.RuleModule;
-        'enforce-id': import("eslint").Rule.RuleModule;
-        'enforce-placeholders': import("eslint").Rule.RuleModule;
-        'enforce-plural-rules': import("eslint").Rule.RuleModule;
-        'no-camel-case': import("eslint").Rule.RuleModule;
-        'no-complex-selectors': import("eslint").Rule.RuleModule;
-        'no-emoji': import("eslint").Rule.RuleModule;
-        'no-id': import("eslint").Rule.RuleModule;
-        'no-invalid-icu': import("eslint").Rule.RuleModule;
-        'no-literal-string-in-jsx': import("eslint").Rule.RuleModule;
-        'no-multiple-plurals': import("eslint").Rule.RuleModule;
-        'no-multiple-whitespaces': import("eslint").Rule.RuleModule;
-        'no-offset': import("eslint").Rule.RuleModule;
-        'no-useless-message': import("eslint").Rule.RuleModule;
-        'prefer-formatted-message': import("eslint").Rule.RuleModule;
-        'prefer-pound-in-plural': import("eslint").Rule.RuleModule;
-    };
+import { RuleModule } from '@typescript-eslint/utils/ts-eslint';
+export type Plugin = {
+    rules: Record<string, RuleModule<string, readonly unknown[]>>;
 };
-export type Plugin = typeof plugin;
-export {};

package/index.js

@@ -1,44 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const blocklist_elements_1 = tslib_1.__importDefault(require("./rules/blocklist-elements"));
-const enforce_default_message_1 = tslib_1.__importDefault(require("./rules/enforce-default-message"));
-const enforce_description_1 = tslib_1.__importDefault(require("./rules/enforce-description"));
-const enforce_id_1 = tslib_1.__importDefault(require("./rules/enforce-id"));
-const enforce_placeholders_1 = tslib_1.__importDefault(require("./rules/enforce-placeholders"));
-const no_invalid_icu_1 = tslib_1.__importDefault(require("./rules/no-invalid-icu"));
-const enforce_plural_rules_1 = tslib_1.__importDefault(require("./rules/enforce-plural-rules"));
-const no_camel_case_1 = tslib_1.__importDefault(require("./rules/no-camel-case"));
-const no_complex_selectors_1 = tslib_1.__importDefault(require("./rules/no-complex-selectors"));
-const no_emoji_1 = tslib_1.__importDefault(require("./rules/no-emoji"));
-const no_id_1 = tslib_1.__importDefault(require("./rules/no-id"));
-const no_multiple_plurals_1 = tslib_1.__importDefault(require("./rules/no-multiple-plurals"));
-const no_multiple_whitespaces_1 = tslib_1.__importDefault(require("./rules/no-multiple-whitespaces"));
-const no_offset_1 = tslib_1.__importDefault(require("./rules/no-offset"));
-const no_literal_string_in_jsx_1 = tslib_1.__importDefault(require("./rules/no-literal-string-in-jsx"));
-const no_useless_message_1 = tslib_1.__importDefault(require("./rules/no-useless-message"));
-const prefer_formatted_message_1 = tslib_1.__importDefault(require("./rules/prefer-formatted-message"));
-const prefer_pound_in_plural_1 = tslib_1.__importDefault(require("./rules/prefer-pound-in-plural"));
+const blocklist_elements_1 = require("./rules/blocklist-elements");
+const enforce_default_message_1 = require("./rules/enforce-default-message");
+const enforce_description_1 = require("./rules/enforce-description");
+const enforce_id_1 = require("./rules/enforce-id");
+const enforce_placeholders_1 = require("./rules/enforce-placeholders");
+const no_invalid_icu_1 = require("./rules/no-invalid-icu");
+const enforce_plural_rules_1 = require("./rules/enforce-plural-rules");
+const no_camel_case_1 = require("./rules/no-camel-case");
+const no_complex_selectors_1 = require("./rules/no-complex-selectors");
+const no_emoji_1 = require("./rules/no-emoji");
+const no_id_1 = require("./rules/no-id");
+const no_multiple_plurals_1 = require("./rules/no-multiple-plurals");
+const no_multiple_whitespaces_1 = require("./rules/no-multiple-whitespaces");
+const no_offset_1 = require("./rules/no-offset");
+const no_literal_string_in_jsx_1 = require("./rules/no-literal-string-in-jsx");
+const no_useless_message_1 = require("./rules/no-useless-message");
+const prefer_formatted_message_1 = require("./rules/prefer-formatted-message");
+const prefer_pound_in_plural_1 = require("./rules/prefer-pound-in-plural");
 const plugin = {
     rules: {
-        'blocklist-elements': blocklist_elements_1.default,
-        'enforce-default-message': enforce_default_message_1.default,
-        'enforce-description': enforce_description_1.default,
-        'enforce-id': enforce_id_1.default,
-        'enforce-placeholders': enforce_placeholders_1.default,
-        'enforce-plural-rules': enforce_plural_rules_1.default,
-        'no-camel-case': no_camel_case_1.default,
-        'no-complex-selectors': no_complex_selectors_1.default,
-        'no-emoji': no_emoji_1.default,
-        'no-id': no_id_1.default,
-        'no-invalid-icu': no_invalid_icu_1.default,
-        'no-literal-string-in-jsx': no_literal_string_in_jsx_1.default,
-        'no-multiple-plurals': no_multiple_plurals_1.default,
-        'no-multiple-whitespaces': no_multiple_whitespaces_1.default,
-        'no-offset': no_offset_1.default,
-        'no-useless-message': no_useless_message_1.default,
-        'prefer-formatted-message': prefer_formatted_message_1.default,
-        'prefer-pound-in-plural': prefer_pound_in_plural_1.default,
+        [blocklist_elements_1.name]: blocklist_elements_1.rule,
+        [enforce_default_message_1.name]: enforce_default_message_1.rule,
+        [enforce_description_1.name]: enforce_description_1.rule,
+        [enforce_id_1.name]: enforce_id_1.rule,
+        [enforce_placeholders_1.name]: enforce_placeholders_1.rule,
+        [enforce_plural_rules_1.name]: enforce_plural_rules_1.rule,
+        [no_camel_case_1.name]: no_camel_case_1.rule,
+        [no_complex_selectors_1.name]: no_complex_selectors_1.rule,
+        [no_emoji_1.name]: no_emoji_1.rule,
+        [no_id_1.name]: no_id_1.rule,
+        [no_invalid_icu_1.name]: no_invalid_icu_1.rule,
+        [no_literal_string_in_jsx_1.name]: no_literal_string_in_jsx_1.rule,
+        [no_multiple_plurals_1.name]: no_multiple_plurals_1.rule,
+        [no_multiple_whitespaces_1.name]: no_multiple_whitespaces_1.rule,
+        [no_offset_1.name]: no_offset_1.rule,
+        [no_useless_message_1.name]: no_useless_message_1.rule,
+        [prefer_formatted_message_1.name]: prefer_formatted_message_1.rule,
+        [prefer_pound_in_plural_1.name]: prefer_pound_in_plural_1.rule,
     },
 };
 module.exports = plugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-formatjs",
-  "version": "4.11.2",
+  "version": "4.12.0",
   "description": "ESLint plugin for formatjs",
   "main": "index.js",
   "repository": {
@@ -22,15 +22,15 @@
   "dependencies": {
     "@types/eslint": "7 || 8",
     "@types/picomatch": "^2.3.0",
-    "@typescript-eslint/utils": "^6.5.0",
+    "@typescript-eslint/utils": "^6.18.1",
     "emoji-regex": "^10.2.1",
     "magic-string": "^0.30.0",
     "picomatch": "^2.3.1",
     "tslib": "2.6.2",
     "typescript": "5",
-    "unicode-emoji-utils": "^1.1.1",
-    "@formatjs/icu-messageformat-parser": "2.7.2",
-    "@formatjs/ts-transformer": "3.13.8"
+    "unicode-emoji-utils": "^1.2.0",
+    "@formatjs/ts-transformer": "3.13.10",
+    "@formatjs/icu-messageformat-parser": "2.7.4"
   },
   "peerDependencies": {
     "eslint": "7 || 8"

package/rules/blocklist-elements.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';
+type MessageIds = 'blocklist';
+type Options = [Element[]?];
+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: RuleModule<MessageIds, Options, RuleListener>;
+export {};

package/rules/blocklist-elements.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = exports.Element = exports.name = void 0;
 const icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
 const util_1 = require("../util");
-class BlacklistElement extends Error {
-    constructor(type) {
-        super();
-        this.message = `${type} element is blocklisted`;
-    }
+exports.name = 'blocklist-elements';
+function getMessage(type) {
+    return {
+        messageId: 'blocklist',
+        data: { type },
+    };
 }
 var Element;
 (function (Element) {
@@ -19,37 +21,38 @@ var Element;
     Element["selectordinal"] = "selectordinal";
     Element["plural"] = "plural";
     Element["tag"] = "tag";
-})(Element || (Element = {}));
+})(Element || (exports.Element = Element = {}));
 function verifyAst(blocklist, ast) {
+    const errors = [];
     for (const el of ast) {
         if ((0, icu_messageformat_parser_1.isLiteralElement)(el) && blocklist.includes(Element.literal)) {
-            throw new BlacklistElement(Element.literal);
+            errors.push(getMessage(Element.literal));
         }
         if ((0, icu_messageformat_parser_1.isArgumentElement)(el) && blocklist.includes(Element.argument)) {
-            throw new BlacklistElement(Element.argument);
+            errors.push(getMessage(Element.argument));
         }
         if ((0, icu_messageformat_parser_1.isNumberElement)(el) && blocklist.includes(Element.number)) {
-            throw new BlacklistElement(Element.number);
+            errors.push(getMessage(Element.number));
         }
         if ((0, icu_messageformat_parser_1.isDateElement)(el) && blocklist.includes(Element.date)) {
-            throw new BlacklistElement(Element.date);
+            errors.push(getMessage(Element.date));
         }
         if ((0, icu_messageformat_parser_1.isTimeElement)(el) && blocklist.includes(Element.time)) {
-            throw new BlacklistElement(Element.time);
+            errors.push(getMessage(Element.time));
         }
         if ((0, icu_messageformat_parser_1.isSelectElement)(el) && blocklist.includes(Element.select)) {
-            throw new BlacklistElement(Element.select);
+            errors.push(getMessage(Element.select));
         }
         if ((0, icu_messageformat_parser_1.isTagElement)(el) && blocklist.includes(Element.tag)) {
-            throw new BlacklistElement(Element.tag);
+            errors.push(getMessage(Element.tag));
         }
         if ((0, icu_messageformat_parser_1.isPluralElement)(el)) {
             if (blocklist.includes(Element.plural)) {
-                throw new BlacklistElement(Element.argument);
+                errors.push(getMessage(Element.argument));
             }
             if (el.pluralType === 'ordinal' &&
                 blocklist.includes(Element.selectordinal)) {
-                throw new BlacklistElement(Element.selectordinal);
+                errors.push(getMessage(Element.selectordinal));
             }
         }
         if ((0, icu_messageformat_parser_1.isSelectElement)(el) || (0, icu_messageformat_parser_1.isPluralElement)(el)) {
@@ -59,6 +62,7 @@ function verifyAst(blocklist, ast) {
             }
         }
     }
+    return errors;
 }
 function checkNode(context, node) {
     const settings = (0, util_1.getSettings)(context);
@@ -74,54 +78,54 @@ 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(blocklist, (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),
+                node,
+                ...error,
             });
         }
     }
 }
-const rule = {
+const 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,
+        }, {
+            CallExpression: callExpressionVisitor,
+        });
+    }
+    return {
+        JSXOpeningElement: (node) => checkNode(context, node),
+        CallExpression: callExpressionVisitor,
+    };
+};
+exports.rule = {
     meta: {
         type: 'problem',
         docs: {
             description: 'Disallow specific elements in ICU message format',
-            category: 'Errors',
-            recommended: false,
             url: 'https://formatjs.io/docs/tooling/linter#blocklist-elements',
         },
         fixable: 'code',
         schema: [
             {
                 type: 'array',
-                properties: {
-                    items: {
-                        type: 'string',
-                        enum: Object.keys(Element),
-                    },
+                items: {
+                    type: 'string',
+                    enum: Object.keys(Element),
                 },
             },
         ],
+        messages: {
+            blocklist: `{{type}} element is blocklisted`,
+        },
     },
-    create(context) {
-        const callExpressionVisitor = (node) => checkNode(context, node);
-        if (context.parserServices.defineTemplateBodyVisitor) {
-            return context.parserServices.defineTemplateBodyVisitor({
-                CallExpression: callExpressionVisitor,
-            }, {
-                CallExpression: callExpressionVisitor,
-            });
-        }
-        return {
-            JSXOpeningElement: (node) => checkNode(context, node),
-            CallExpression: callExpressionVisitor,
-        };
-    },
+    defaultOptions: [],
+    create,
 };
-exports.default = rule;

package/rules/enforce-default-message.d.ts

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

package/rules/enforce-default-message.js

@@ -1,6 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = exports.name = exports.Option = void 0;
 const util_1 = require("../util");
+var Option;
+(function (Option) {
+    Option["literal"] = "literal";
+    Option["anything"] = "anything";
+})(Option || (exports.Option = Option = {}));
+exports.name = 'enforce-default-message';
 function checkNode(context, node) {
     const msgs = (0, util_1.extractMessages)(node, (0, util_1.getSettings)(context));
     const { options: [type], } = context;
@@ -9,39 +16,45 @@ function checkNode(context, node) {
             if (type === 'literal' && messageNode) {
                 context.report({
                     node: messageNode,
-                    message: `"defaultMessage" must be:
-- a string literal or
-- template literal without variable`,
+                    messageId: 'defaultMessageLiteral',
                 });
             }
             else if (!messageNode) {
                 context.report({
                     node: node,
-                    message: '`defaultMessage` has to be specified in message descriptor',
+                    messageId: 'defaultMessage',
                 });
             }
         }
     }
 }
-const rule = {
+exports.rule = {
     meta: {
         type: 'problem',
         docs: {
             description: 'Enforce defaultMessage in message descriptor',
-            category: 'Errors',
-            recommended: false,
             url: 'https://formatjs.io/docs/tooling/linter#enforce-default-message',
         },
         fixable: 'code',
         schema: [
             {
-                enum: ['literal', 'anything'],
+                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);
+        //@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
         if (context.parserServices.defineTemplateBodyVisitor) {
+            //@ts-expect-error
             return context.parserServices.defineTemplateBodyVisitor({
                 CallExpression: callExpressionVisitor,
             }, {
@@ -54,4 +67,3 @@ const rule = {
         };
     },
 };
-exports.default = rule;

package/rules/enforce-description.d.ts

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

package/rules/enforce-description.js

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = exports.name = exports.Option = void 0;
 const util_1 = require("../util");
+var Option;
+(function (Option) {
+    Option["literal"] = "literal";
+    Option["anything"] = "anything";
+})(Option || (exports.Option = Option = {}));
 function checkNode(context, node) {
     const msgs = (0, util_1.extractMessages)(node, (0, util_1.getSettings)(context));
     const { options: [type], } = context;
@@ -9,37 +15,44 @@ function checkNode(context, node) {
             if (type === 'literal' && descriptionNode) {
                 context.report({
                     node: descriptionNode,
-                    message: '`description` has to be a string literal (not function call or variable)',
+                    messageId: 'enforceDescriptionLiteral',
                 });
             }
             else if (!descriptionNode) {
                 context.report({
                     node: node,
-                    message: '`description` has to be specified in message descriptor',
+                    messageId: 'enforceDescription',
                 });
             }
         }
     }
 }
-exports.default = {
+exports.name = 'enforce-description';
+exports.rule = {
     meta: {
         type: 'problem',
         docs: {
             description: 'Enforce description in message descriptor',
-            category: 'Errors',
-            recommended: false,
             url: 'https://formatjs.io/docs/tooling/linter#enforce-description',
         },
         fixable: 'code',
         schema: [
             {
-                enum: ['literal', 'anything'],
+                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);
+        //@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
         if (context.parserServices.defineTemplateBodyVisitor) {
+            //@ts-expect-error
             return context.parserServices.defineTemplateBodyVisitor({
                 CallExpression: callExpressionVisitor,
             }, {

package/rules/enforce-id.d.ts

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