eslint-plugin-formatjs 4.11.3 → 4.12.1

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.3",
+  "version": "4.12.1",
   "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.3",
-    "@formatjs/ts-transformer": "3.13.9"
+    "unicode-emoji-utils": "^1.2.0",
+    "@formatjs/icu-messageformat-parser": "2.7.5",
+    "@formatjs/ts-transformer": "3.13.11"
   },
   "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 {};

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